@elastic/elasticsearch 8.14.1 → 8.15.0

package/catalog-info.yaml

@@ -6,7 +6,7 @@ metadata:
   name: elasticsearch-js
 spec:
   type: library
-  owner: group:clients-team
+  owner: group:devtools-team
   lifecycle: production
 
 ---
@@ -18,7 +18,7 @@ metadata:
   description: elasticsearch-js - integration tests
 spec:
   type: buildkite-pipeline
-  owner: group:clients-team
+  owner: group:devtools-team
   system: buildkite
   implementation:
     apiVersion: buildkite.elastic.dev/v1
@@ -29,7 +29,7 @@ spec:
       repository: elastic/elasticsearch-js
       pipeline_file: .buildkite/pipeline.yml
       teams:
-        clients-team:
+        devtools-team:
           access_level: MANAGE_BUILD_AND_READ
         everyone:
           access_level: READ_ONLY
@@ -37,11 +37,11 @@ spec:
         build_pull_requests: false
         build_branches: false
       cancel_intermediate_builds: true
-      cancel_intermediate_builds_branch_filter: '!main'
+      cancel_intermediate_builds_branch_filter: "!main"
       schedules:
         main:
-          branch: 'main'
-          cronline: '@daily'
-        8_13:
-          branch: '8.13'
-          cronline: '@daily'
+          branch: "main"
+          cronline: "@daily"
+        8_14:
+          branch: "8.14"
+          cronline: "@daily"

package/lib/api/api/async_search.d.ts

@@ -8,29 +8,29 @@ export default class AsyncSearch {
     transport: Transport;
     constructor(transport: Transport);
     /**
-      * Deletes an async search by ID. If the search is still running, the search request will be cancelled. Otherwise, the saved search results are deleted.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/async-search.html | Elasticsearch API documentation}
+      * Deletes an async search by identifier. If the search is still running, the search request will be cancelled. Otherwise, the saved search results are deleted. If the Elasticsearch security features are enabled, the deletion of a specific async search is restricted to: the authenticated user that submitted the original search request; users that have the `cancel_task` cluster privilege.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/async-search.html | Elasticsearch API documentation}
       */
     delete(this: That, params: T.AsyncSearchDeleteRequest | TB.AsyncSearchDeleteRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchDeleteResponse>;
     delete(this: That, params: T.AsyncSearchDeleteRequest | TB.AsyncSearchDeleteRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchDeleteResponse, unknown>>;
     delete(this: That, params: T.AsyncSearchDeleteRequest | TB.AsyncSearchDeleteRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchDeleteResponse>;
     /**
-      * Retrieves the results of a previously submitted async search request given its ID.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/async-search.html | Elasticsearch API documentation}
+      * Retrieves the results of a previously submitted async search request given its identifier. If the Elasticsearch security features are enabled, access to the results of a specific async search is restricted to the user or API key that submitted it.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/async-search.html | Elasticsearch API documentation}
       */
     get<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>>(this: That, params: T.AsyncSearchGetRequest | TB.AsyncSearchGetRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchGetResponse<TDocument, TAggregations>>;
     get<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>>(this: That, params: T.AsyncSearchGetRequest | TB.AsyncSearchGetRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchGetResponse<TDocument, TAggregations>, unknown>>;
     get<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>>(this: That, params: T.AsyncSearchGetRequest | TB.AsyncSearchGetRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchGetResponse<TDocument, TAggregations>>;
     /**
-      * Retrieves the status of a previously submitted async search request given its ID.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/async-search.html | Elasticsearch API documentation}
+      * Get async search status Retrieves the status of a previously submitted async search request given its identifier, without retrieving search results. If the Elasticsearch security features are enabled, use of this API is restricted to the `monitoring_user` role.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/async-search.html | Elasticsearch API documentation}
       */
     status(this: That, params: T.AsyncSearchStatusRequest | TB.AsyncSearchStatusRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchStatusResponse>;
     status(this: That, params: T.AsyncSearchStatusRequest | TB.AsyncSearchStatusRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchStatusResponse, unknown>>;
     status(this: That, params: T.AsyncSearchStatusRequest | TB.AsyncSearchStatusRequest, options?: TransportRequestOptions): Promise<T.AsyncSearchStatusResponse>;
     /**
-      * Executes a search request asynchronously.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/async-search.html | Elasticsearch API documentation}
+      * Runs a search request asynchronously. When the primary sort of the results is an indexed field, shards get sorted based on minimum and maximum value that they hold for that field, hence partial results become available following the sort criteria that was requested. Warning: Async search does not support scroll nor search requests that only include the suggest section. By default, Elasticsearch doesn’t allow you to store an async search response larger than 10Mb and an attempt to do this results in an error. The maximum allowed size for a stored async search response can be set by changing the `search.max_async_search_response_size` cluster level setting.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/async-search.html | Elasticsearch API documentation}
       */
     submit<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>>(this: That, params?: T.AsyncSearchSubmitRequest | TB.AsyncSearchSubmitRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AsyncSearchSubmitResponse<TDocument, TAggregations>>;
     submit<TDocument = unknown, TAggregations = Record<T.AggregateName, T.AggregationsAggregate>>(this: That, params?: T.AsyncSearchSubmitRequest | TB.AsyncSearchSubmitRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AsyncSearchSubmitResponse<TDocument, TAggregations>, unknown>>;

package/lib/api/api/autoscaling.d.ts

@@ -9,28 +9,28 @@ export default class Autoscaling {
     constructor(transport: Transport);
     /**
       * Deletes an autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/autoscaling-delete-autoscaling-policy.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/autoscaling-delete-autoscaling-policy.html | Elasticsearch API documentation}
       */
     deleteAutoscalingPolicy(this: That, params: T.AutoscalingDeleteAutoscalingPolicyRequest | TB.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingDeleteAutoscalingPolicyResponse>;
     deleteAutoscalingPolicy(this: That, params: T.AutoscalingDeleteAutoscalingPolicyRequest | TB.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingDeleteAutoscalingPolicyResponse, unknown>>;
     deleteAutoscalingPolicy(this: That, params: T.AutoscalingDeleteAutoscalingPolicyRequest | TB.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptions): Promise<T.AutoscalingDeleteAutoscalingPolicyResponse>;
     /**
       * Gets the current autoscaling capacity based on the configured autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/autoscaling-get-autoscaling-capacity.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/autoscaling-get-autoscaling-capacity.html | Elasticsearch API documentation}
       */
     getAutoscalingCapacity(this: That, params?: T.AutoscalingGetAutoscalingCapacityRequest | TB.AutoscalingGetAutoscalingCapacityRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingGetAutoscalingCapacityResponse>;
     getAutoscalingCapacity(this: That, params?: T.AutoscalingGetAutoscalingCapacityRequest | TB.AutoscalingGetAutoscalingCapacityRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingGetAutoscalingCapacityResponse, unknown>>;
     getAutoscalingCapacity(this: That, params?: T.AutoscalingGetAutoscalingCapacityRequest | TB.AutoscalingGetAutoscalingCapacityRequest, options?: TransportRequestOptions): Promise<T.AutoscalingGetAutoscalingCapacityResponse>;
     /**
       * Retrieves an autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/autoscaling-get-autoscaling-capacity.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/autoscaling-get-autoscaling-capacity.html | Elasticsearch API documentation}
       */
     getAutoscalingPolicy(this: That, params: T.AutoscalingGetAutoscalingPolicyRequest | TB.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingGetAutoscalingPolicyResponse>;
     getAutoscalingPolicy(this: That, params: T.AutoscalingGetAutoscalingPolicyRequest | TB.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingGetAutoscalingPolicyResponse, unknown>>;
     getAutoscalingPolicy(this: That, params: T.AutoscalingGetAutoscalingPolicyRequest | TB.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptions): Promise<T.AutoscalingGetAutoscalingPolicyResponse>;
     /**
       * Creates a new autoscaling policy. Designed for indirect use by ECE/ESS and ECK. Direct use is not supported.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/autoscaling-put-autoscaling-policy.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/autoscaling-put-autoscaling-policy.html | Elasticsearch API documentation}
       */
     putAutoscalingPolicy(this: That, params: T.AutoscalingPutAutoscalingPolicyRequest | TB.AutoscalingPutAutoscalingPolicyRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.AutoscalingPutAutoscalingPolicyResponse>;
     putAutoscalingPolicy(this: That, params: T.AutoscalingPutAutoscalingPolicyRequest | TB.AutoscalingPutAutoscalingPolicyRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.AutoscalingPutAutoscalingPolicyResponse, unknown>>;

package/lib/api/api/bulk.d.ts

@@ -5,8 +5,8 @@ interface That {
     transport: Transport;
 }
 /**
-  * Allows to perform multiple index/update/delete operations in a single request.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/docs-bulk.html | Elasticsearch API documentation}
+  * Performs multiple indexing or delete operations in a single API call. This reduces overhead and can greatly increase indexing speed.
+  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/docs-bulk.html | Elasticsearch API documentation}
   */
 export default function BulkApi<TDocument = unknown, TPartialDocument = unknown>(this: That, params: T.BulkRequest<TDocument, TPartialDocument> | TB.BulkRequest<TDocument, TPartialDocument>, options?: TransportRequestOptionsWithOutMeta): Promise<T.BulkResponse>;
 export default function BulkApi<TDocument = unknown, TPartialDocument = unknown>(this: That, params: T.BulkRequest<TDocument, TPartialDocument> | TB.BulkRequest<TDocument, TPartialDocument>, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.BulkResponse, unknown>>;

package/lib/api/api/capabilities.d.ts

@@ -0,0 +1,14 @@
+import { Transport, TransportRequestOptions, TransportRequestOptionsWithMeta, TransportRequestOptionsWithOutMeta, TransportResult } from '@elastic/transport';
+import * as T from '../types';
+import * as TB from '../typesWithBodyKey';
+interface That {
+    transport: Transport;
+}
+/**
+  * Checks if the specified combination of method, API, parameters, and arbitrary capabilities are supported
+  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/capabilities.html | Elasticsearch API documentation}
+  */
+export default function CapabilitiesApi(this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithOutMeta): Promise<T.TODO>;
+export default function CapabilitiesApi(this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.TODO, unknown>>;
+export default function CapabilitiesApi(this: That, params?: T.TODO | TB.TODO, options?: TransportRequestOptions): Promise<T.TODO>;
+export {};

package/lib/api/api/capabilities.js

@@ -0,0 +1,42 @@
+"use strict";
+/*
+ * Licensed to Elasticsearch B.V. under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch B.V. licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+async function CapabilitiesApi(params, options) {
+    const acceptedPath = [];
+    const querystring = {};
+    const body = undefined;
+    params = params !== null && params !== void 0 ? params : {};
+    for (const key in params) {
+        if (acceptedPath.includes(key)) {
+            continue;
+        }
+        else if (key !== 'body') {
+            querystring[key] = params[key];
+        }
+    }
+    const method = 'GET';
+    const path = '/_capabilities';
+    const meta = {
+        name: 'capabilities'
+    };
+    return await this.transport.request({ path, method, querystring, body, meta }, options);
+}
+exports.default = CapabilitiesApi;
+//# sourceMappingURL=capabilities.js.map

package/lib/api/api/capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.js","sourceRoot":"","sources":["../../../src/api/api/capabilities.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;AA8BY,KAAK,UAAU,eAAe,CAAc,MAAyB,EAAE,OAAiC;IACrH,MAAM,YAAY,GAAa,EAAE,CAAA;IACjC,MAAM,WAAW,GAAwB,EAAE,CAAA;IAC3C,MAAM,IAAI,GAAG,SAAS,CAAA;IAEtB,MAAM,GAAG,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAA;IACrB,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE;QACxB,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;YAC9B,SAAQ;SACT;aAAM,IAAI,GAAG,KAAK,MAAM,EAAE;YACzB,WAAW,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAA;SAC/B;KACF;IAED,MAAM,MAAM,GAAG,KAAK,CAAA;IACpB,MAAM,IAAI,GAAG,gBAAgB,CAAA;IAC7B,MAAM,IAAI,GAA6B;QACrC,IAAI,EAAE,cAAc;KACrB,CAAA;IACD,OAAO,MAAM,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,OAAO,CAAC,CAAA;AACzF,CAAC;AApBD,kCAoBC"}

package/lib/api/api/cat.d.ts

@@ -8,183 +8,183 @@ export default class Cat {
     transport: Transport;
     constructor(transport: Transport);
     /**
-      * Shows information about currently configured aliases to indices including filter and routing infos.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-alias.html | Elasticsearch API documentation}
+      * Retrieves the cluster’s index aliases, including filter and routing information. The API does not return data stream aliases. IMPORTANT: cat APIs are only intended for human consumption using the command line or the Kibana console. They are not intended for use by applications. For application consumption, use the aliases API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-alias.html | Elasticsearch API documentation}
       */
     aliases(this: That, params?: T.CatAliasesRequest | TB.CatAliasesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatAliasesResponse>;
     aliases(this: That, params?: T.CatAliasesRequest | TB.CatAliasesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatAliasesResponse, unknown>>;
     aliases(this: That, params?: T.CatAliasesRequest | TB.CatAliasesRequest, options?: TransportRequestOptions): Promise<T.CatAliasesResponse>;
     /**
-      * Provides a snapshot of how many shards are allocated to each data node and how much disk space they are using.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-allocation.html | Elasticsearch API documentation}
+      * Provides a snapshot of the number of shards allocated to each data node and their disk space. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-allocation.html | Elasticsearch API documentation}
       */
     allocation(this: That, params?: T.CatAllocationRequest | TB.CatAllocationRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatAllocationResponse>;
     allocation(this: That, params?: T.CatAllocationRequest | TB.CatAllocationRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatAllocationResponse, unknown>>;
     allocation(this: That, params?: T.CatAllocationRequest | TB.CatAllocationRequest, options?: TransportRequestOptions): Promise<T.CatAllocationResponse>;
     /**
-      * Returns information about existing component_templates templates.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-component-templates.html | Elasticsearch API documentation}
+      * Returns information about component templates in a cluster. Component templates are building blocks for constructing index templates that specify index mappings, settings, and aliases. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get component template API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-component-templates.html | Elasticsearch API documentation}
       */
     componentTemplates(this: That, params?: T.CatComponentTemplatesRequest | TB.CatComponentTemplatesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatComponentTemplatesResponse>;
     componentTemplates(this: That, params?: T.CatComponentTemplatesRequest | TB.CatComponentTemplatesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatComponentTemplatesResponse, unknown>>;
     componentTemplates(this: That, params?: T.CatComponentTemplatesRequest | TB.CatComponentTemplatesRequest, options?: TransportRequestOptions): Promise<T.CatComponentTemplatesResponse>;
     /**
-      * Provides quick access to the document count of the entire cluster, or individual indices.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-count.html | Elasticsearch API documentation}
+      * Provides quick access to a document count for a data stream, an index, or an entire cluster. NOTE: The document count only includes live documents, not deleted documents which have not yet been removed by the merge process. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the count API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-count.html | Elasticsearch API documentation}
       */
     count(this: That, params?: T.CatCountRequest | TB.CatCountRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatCountResponse>;
     count(this: That, params?: T.CatCountRequest | TB.CatCountRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatCountResponse, unknown>>;
     count(this: That, params?: T.CatCountRequest | TB.CatCountRequest, options?: TransportRequestOptions): Promise<T.CatCountResponse>;
     /**
-      * Shows how much heap memory is currently being used by fielddata on every data node in the cluster.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-fielddata.html | Elasticsearch API documentation}
+      * Returns the amount of heap memory currently used by the field data cache on every data node in the cluster. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes stats API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-fielddata.html | Elasticsearch API documentation}
       */
     fielddata(this: That, params?: T.CatFielddataRequest | TB.CatFielddataRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatFielddataResponse>;
     fielddata(this: That, params?: T.CatFielddataRequest | TB.CatFielddataRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatFielddataResponse, unknown>>;
     fielddata(this: That, params?: T.CatFielddataRequest | TB.CatFielddataRequest, options?: TransportRequestOptions): Promise<T.CatFielddataResponse>;
     /**
-      * Returns a concise representation of the cluster health.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-health.html | Elasticsearch API documentation}
+      * Returns the health status of a cluster, similar to the cluster health API. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the cluster health API. This API is often used to check malfunctioning clusters. To help you track cluster health alongside log files and alerting systems, the API returns timestamps in two formats: `HH:MM:SS`, which is human-readable but includes no date information; `Unix epoch time`, which is machine-sortable and includes date information. The latter format is useful for cluster recoveries that take multiple days. You can use the cat health API to verify cluster health across multiple nodes. You also can use the API to track the recovery of a large cluster over a longer period of time.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-health.html | Elasticsearch API documentation}
       */
     health(this: That, params?: T.CatHealthRequest | TB.CatHealthRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatHealthResponse>;
     health(this: That, params?: T.CatHealthRequest | TB.CatHealthRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatHealthResponse, unknown>>;
     health(this: That, params?: T.CatHealthRequest | TB.CatHealthRequest, options?: TransportRequestOptions): Promise<T.CatHealthResponse>;
     /**
       * Returns help for the Cat APIs.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat.html | Elasticsearch API documentation}
       */
     help(this: That, params?: T.CatHelpRequest | TB.CatHelpRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatHelpResponse>;
     help(this: That, params?: T.CatHelpRequest | TB.CatHelpRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatHelpResponse, unknown>>;
     help(this: That, params?: T.CatHelpRequest | TB.CatHelpRequest, options?: TransportRequestOptions): Promise<T.CatHelpResponse>;
     /**
-      * Returns information about indices: number of primaries and replicas, document counts, disk size, ...
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-indices.html | Elasticsearch API documentation}
+      * Returns high-level information about indices in a cluster, including backing indices for data streams. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get index API. Use the cat indices API to get the following information for each index in a cluster: shard count; document count; deleted document count; primary store size; total store size of all shards, including shard replicas. These metrics are retrieved directly from Lucene, which Elasticsearch uses internally to power indexing and search. As a result, all document counts include hidden nested documents. To get an accurate count of Elasticsearch documents, use the cat count or count APIs.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-indices.html | Elasticsearch API documentation}
       */
     indices(this: That, params?: T.CatIndicesRequest | TB.CatIndicesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatIndicesResponse>;
     indices(this: That, params?: T.CatIndicesRequest | TB.CatIndicesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatIndicesResponse, unknown>>;
     indices(this: That, params?: T.CatIndicesRequest | TB.CatIndicesRequest, options?: TransportRequestOptions): Promise<T.CatIndicesResponse>;
     /**
-      * Returns information about the master node.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-master.html | Elasticsearch API documentation}
+      * Returns information about the master node, including the ID, bound IP address, and name. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-master.html | Elasticsearch API documentation}
       */
     master(this: That, params?: T.CatMasterRequest | TB.CatMasterRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMasterResponse>;
     master(this: That, params?: T.CatMasterRequest | TB.CatMasterRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMasterResponse, unknown>>;
     master(this: That, params?: T.CatMasterRequest | TB.CatMasterRequest, options?: TransportRequestOptions): Promise<T.CatMasterResponse>;
     /**
-      * Gets configuration and usage information about data frame analytics jobs.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-dfanalytics.html | Elasticsearch API documentation}
+      * Returns configuration and usage information about data frame analytics jobs. IMPORTANT: cat APIs are only intended for human consumption using the Kibana console or command line. They are not intended for use by applications. For application consumption, use the get data frame analytics jobs statistics API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-dfanalytics.html | Elasticsearch API documentation}
       */
     mlDataFrameAnalytics(this: That, params?: T.CatMlDataFrameAnalyticsRequest | TB.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlDataFrameAnalyticsResponse>;
     mlDataFrameAnalytics(this: That, params?: T.CatMlDataFrameAnalyticsRequest | TB.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlDataFrameAnalyticsResponse, unknown>>;
     mlDataFrameAnalytics(this: That, params?: T.CatMlDataFrameAnalyticsRequest | TB.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptions): Promise<T.CatMlDataFrameAnalyticsResponse>;
     /**
-      * Gets configuration and usage information about datafeeds.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-datafeeds.html | Elasticsearch API documentation}
+      * Returns configuration and usage information about datafeeds. This API returns a maximum of 10,000 datafeeds. If the Elasticsearch security features are enabled, you must have `monitor_ml`, `monitor`, `manage_ml`, or `manage` cluster privileges to use this API. IMPORTANT: cat APIs are only intended for human consumption using the Kibana console or command line. They are not intended for use by applications. For application consumption, use the get datafeed statistics API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-datafeeds.html | Elasticsearch API documentation}
       */
     mlDatafeeds(this: That, params?: T.CatMlDatafeedsRequest | TB.CatMlDatafeedsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlDatafeedsResponse>;
     mlDatafeeds(this: That, params?: T.CatMlDatafeedsRequest | TB.CatMlDatafeedsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlDatafeedsResponse, unknown>>;
     mlDatafeeds(this: That, params?: T.CatMlDatafeedsRequest | TB.CatMlDatafeedsRequest, options?: TransportRequestOptions): Promise<T.CatMlDatafeedsResponse>;
     /**
-      * Gets configuration and usage information about anomaly detection jobs.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-anomaly-detectors.html | Elasticsearch API documentation}
+      * Returns configuration and usage information for anomaly detection jobs. This API returns a maximum of 10,000 jobs. If the Elasticsearch security features are enabled, you must have `monitor_ml`, `monitor`, `manage_ml`, or `manage` cluster privileges to use this API. IMPORTANT: cat APIs are only intended for human consumption using the Kibana console or command line. They are not intended for use by applications. For application consumption, use the get anomaly detection job statistics API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-anomaly-detectors.html | Elasticsearch API documentation}
       */
     mlJobs(this: That, params?: T.CatMlJobsRequest | TB.CatMlJobsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlJobsResponse>;
     mlJobs(this: That, params?: T.CatMlJobsRequest | TB.CatMlJobsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlJobsResponse, unknown>>;
     mlJobs(this: That, params?: T.CatMlJobsRequest | TB.CatMlJobsRequest, options?: TransportRequestOptions): Promise<T.CatMlJobsResponse>;
     /**
-      * Gets configuration and usage information about inference trained models.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-trained-model.html | Elasticsearch API documentation}
+      * Returns configuration and usage information about inference trained models. IMPORTANT: cat APIs are only intended for human consumption using the Kibana console or command line. They are not intended for use by applications. For application consumption, use the get trained models statistics API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-trained-model.html | Elasticsearch API documentation}
       */
     mlTrainedModels(this: That, params?: T.CatMlTrainedModelsRequest | TB.CatMlTrainedModelsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatMlTrainedModelsResponse>;
     mlTrainedModels(this: That, params?: T.CatMlTrainedModelsRequest | TB.CatMlTrainedModelsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatMlTrainedModelsResponse, unknown>>;
     mlTrainedModels(this: That, params?: T.CatMlTrainedModelsRequest | TB.CatMlTrainedModelsRequest, options?: TransportRequestOptions): Promise<T.CatMlTrainedModelsResponse>;
     /**
-      * Returns information about custom node attributes.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-nodeattrs.html | Elasticsearch API documentation}
+      * Returns information about custom node attributes. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-nodeattrs.html | Elasticsearch API documentation}
       */
     nodeattrs(this: That, params?: T.CatNodeattrsRequest | TB.CatNodeattrsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatNodeattrsResponse>;
     nodeattrs(this: That, params?: T.CatNodeattrsRequest | TB.CatNodeattrsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatNodeattrsResponse, unknown>>;
     nodeattrs(this: That, params?: T.CatNodeattrsRequest | TB.CatNodeattrsRequest, options?: TransportRequestOptions): Promise<T.CatNodeattrsResponse>;
     /**
-      * Returns basic statistics about performance of cluster nodes.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-nodes.html | Elasticsearch API documentation}
+      * Returns information about the nodes in a cluster. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-nodes.html | Elasticsearch API documentation}
       */
     nodes(this: That, params?: T.CatNodesRequest | TB.CatNodesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatNodesResponse>;
     nodes(this: That, params?: T.CatNodesRequest | TB.CatNodesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatNodesResponse, unknown>>;
     nodes(this: That, params?: T.CatNodesRequest | TB.CatNodesRequest, options?: TransportRequestOptions): Promise<T.CatNodesResponse>;
     /**
-      * Returns a concise representation of the cluster pending tasks.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-pending-tasks.html | Elasticsearch API documentation}
+      * Returns cluster-level changes that have not yet been executed. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the pending cluster tasks API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-pending-tasks.html | Elasticsearch API documentation}
       */
     pendingTasks(this: That, params?: T.CatPendingTasksRequest | TB.CatPendingTasksRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatPendingTasksResponse>;
     pendingTasks(this: That, params?: T.CatPendingTasksRequest | TB.CatPendingTasksRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatPendingTasksResponse, unknown>>;
     pendingTasks(this: That, params?: T.CatPendingTasksRequest | TB.CatPendingTasksRequest, options?: TransportRequestOptions): Promise<T.CatPendingTasksResponse>;
     /**
-      * Returns information about installed plugins across nodes node.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-plugins.html | Elasticsearch API documentation}
+      * Returns a list of plugins running on each node of a cluster. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-plugins.html | Elasticsearch API documentation}
       */
     plugins(this: That, params?: T.CatPluginsRequest | TB.CatPluginsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatPluginsResponse>;
     plugins(this: That, params?: T.CatPluginsRequest | TB.CatPluginsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatPluginsResponse, unknown>>;
     plugins(this: That, params?: T.CatPluginsRequest | TB.CatPluginsRequest, options?: TransportRequestOptions): Promise<T.CatPluginsResponse>;
     /**
-      * Returns information about index shard recoveries, both on-going completed.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-recovery.html | Elasticsearch API documentation}
+      * Returns information about ongoing and completed shard recoveries. Shard recovery is the process of initializing a shard copy, such as restoring a primary shard from a snapshot or syncing a replica shard from a primary shard. When a shard recovery completes, the recovered shard is available for search and indexing. For data streams, the API returns information about the stream’s backing indices. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index recovery API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-recovery.html | Elasticsearch API documentation}
       */
     recovery(this: That, params?: T.CatRecoveryRequest | TB.CatRecoveryRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatRecoveryResponse>;
     recovery(this: That, params?: T.CatRecoveryRequest | TB.CatRecoveryRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatRecoveryResponse, unknown>>;
     recovery(this: That, params?: T.CatRecoveryRequest | TB.CatRecoveryRequest, options?: TransportRequestOptions): Promise<T.CatRecoveryResponse>;
     /**
-      * Returns information about snapshot repositories registered in the cluster.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-repositories.html | Elasticsearch API documentation}
+      * Returns the snapshot repositories for a cluster. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get snapshot repository API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-repositories.html | Elasticsearch API documentation}
       */
     repositories(this: That, params?: T.CatRepositoriesRequest | TB.CatRepositoriesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatRepositoriesResponse>;
     repositories(this: That, params?: T.CatRepositoriesRequest | TB.CatRepositoriesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatRepositoriesResponse, unknown>>;
     repositories(this: That, params?: T.CatRepositoriesRequest | TB.CatRepositoriesRequest, options?: TransportRequestOptions): Promise<T.CatRepositoriesResponse>;
     /**
-      * Provides low-level information about the segments in the shards of an index.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-segments.html | Elasticsearch API documentation}
+      * Returns low-level information about the Lucene segments in index shards. For data streams, the API returns information about the backing indices. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the index segments API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-segments.html | Elasticsearch API documentation}
       */
     segments(this: That, params?: T.CatSegmentsRequest | TB.CatSegmentsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatSegmentsResponse>;
     segments(this: That, params?: T.CatSegmentsRequest | TB.CatSegmentsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatSegmentsResponse, unknown>>;
     segments(this: That, params?: T.CatSegmentsRequest | TB.CatSegmentsRequest, options?: TransportRequestOptions): Promise<T.CatSegmentsResponse>;
     /**
-      * Provides a detailed view of shard allocation on nodes.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-shards.html | Elasticsearch API documentation}
+      * Returns information about the shards in a cluster. For data streams, the API returns information about the backing indices. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-shards.html | Elasticsearch API documentation}
       */
     shards(this: That, params?: T.CatShardsRequest | TB.CatShardsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatShardsResponse>;
     shards(this: That, params?: T.CatShardsRequest | TB.CatShardsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatShardsResponse, unknown>>;
     shards(this: That, params?: T.CatShardsRequest | TB.CatShardsRequest, options?: TransportRequestOptions): Promise<T.CatShardsResponse>;
     /**
-      * Returns all snapshots in a specific repository.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-snapshots.html | Elasticsearch API documentation}
+      * Returns information about the snapshots stored in one or more repositories. A snapshot is a backup of an index or running Elasticsearch cluster. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get snapshot API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-snapshots.html | Elasticsearch API documentation}
       */
     snapshots(this: That, params?: T.CatSnapshotsRequest | TB.CatSnapshotsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatSnapshotsResponse>;
     snapshots(this: That, params?: T.CatSnapshotsRequest | TB.CatSnapshotsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatSnapshotsResponse, unknown>>;
     snapshots(this: That, params?: T.CatSnapshotsRequest | TB.CatSnapshotsRequest, options?: TransportRequestOptions): Promise<T.CatSnapshotsResponse>;
     /**
-      * Returns information about the tasks currently executing on one or more nodes in the cluster.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/tasks.html | Elasticsearch API documentation}
+      * Returns information about tasks currently executing in the cluster. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the task management API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/tasks.html | Elasticsearch API documentation}
       */
     tasks(this: That, params?: T.CatTasksRequest | TB.CatTasksRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatTasksResponse>;
     tasks(this: That, params?: T.CatTasksRequest | TB.CatTasksRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatTasksResponse, unknown>>;
     tasks(this: That, params?: T.CatTasksRequest | TB.CatTasksRequest, options?: TransportRequestOptions): Promise<T.CatTasksResponse>;
     /**
-      * Returns information about existing templates.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-templates.html | Elasticsearch API documentation}
+      * Returns information about index templates in a cluster. You can use index templates to apply index settings and field mappings to new indices at creation. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the get index template API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-templates.html | Elasticsearch API documentation}
       */
     templates(this: That, params?: T.CatTemplatesRequest | TB.CatTemplatesRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatTemplatesResponse>;
     templates(this: That, params?: T.CatTemplatesRequest | TB.CatTemplatesRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatTemplatesResponse, unknown>>;
     templates(this: That, params?: T.CatTemplatesRequest | TB.CatTemplatesRequest, options?: TransportRequestOptions): Promise<T.CatTemplatesResponse>;
     /**
-      * Returns cluster-wide thread pool statistics per node. By default the active, queue and rejected statistics are returned for all thread pools.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-thread-pool.html | Elasticsearch API documentation}
+      * Returns thread pool statistics for each node in a cluster. Returned information includes all built-in thread pools and custom thread pools. IMPORTANT: cat APIs are only intended for human consumption using the command line or Kibana console. They are not intended for use by applications. For application consumption, use the nodes info API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-thread-pool.html | Elasticsearch API documentation}
       */
     threadPool(this: That, params?: T.CatThreadPoolRequest | TB.CatThreadPoolRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatThreadPoolResponse>;
     threadPool(this: That, params?: T.CatThreadPoolRequest | TB.CatThreadPoolRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatThreadPoolResponse, unknown>>;
     threadPool(this: That, params?: T.CatThreadPoolRequest | TB.CatThreadPoolRequest, options?: TransportRequestOptions): Promise<T.CatThreadPoolResponse>;
     /**
-      * Gets configuration and usage information about transforms.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/cat-transforms.html | Elasticsearch API documentation}
+      * Returns configuration and usage information about transforms. IMPORTANT: cat APIs are only intended for human consumption using the Kibana console or command line. They are not intended for use by applications. For application consumption, use the get transform statistics API.
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/cat-transforms.html | Elasticsearch API documentation}
       */
     transforms(this: That, params?: T.CatTransformsRequest | TB.CatTransformsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CatTransformsResponse>;
     transforms(this: That, params?: T.CatTransformsRequest | TB.CatTransformsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CatTransformsResponse, unknown>>;

package/lib/api/api/ccr.d.ts

@@ -9,91 +9,91 @@ export default class Ccr {
     constructor(transport: Transport);
     /**
       * Deletes auto-follow patterns.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-delete-auto-follow-pattern.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-delete-auto-follow-pattern.html | Elasticsearch API documentation}
       */
     deleteAutoFollowPattern(this: That, params: T.CcrDeleteAutoFollowPatternRequest | TB.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrDeleteAutoFollowPatternResponse>;
     deleteAutoFollowPattern(this: That, params: T.CcrDeleteAutoFollowPatternRequest | TB.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrDeleteAutoFollowPatternResponse, unknown>>;
     deleteAutoFollowPattern(this: That, params: T.CcrDeleteAutoFollowPatternRequest | TB.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrDeleteAutoFollowPatternResponse>;
     /**
       * Creates a new follower index configured to follow the referenced leader index.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-put-follow.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-put-follow.html | Elasticsearch API documentation}
       */
     follow(this: That, params: T.CcrFollowRequest | TB.CcrFollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrFollowResponse>;
     follow(this: That, params: T.CcrFollowRequest | TB.CcrFollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrFollowResponse, unknown>>;
     follow(this: That, params: T.CcrFollowRequest | TB.CcrFollowRequest, options?: TransportRequestOptions): Promise<T.CcrFollowResponse>;
     /**
       * Retrieves information about all follower indices, including parameters and status for each follower index
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-get-follow-info.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-get-follow-info.html | Elasticsearch API documentation}
       */
     followInfo(this: That, params: T.CcrFollowInfoRequest | TB.CcrFollowInfoRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrFollowInfoResponse>;
     followInfo(this: That, params: T.CcrFollowInfoRequest | TB.CcrFollowInfoRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrFollowInfoResponse, unknown>>;
     followInfo(this: That, params: T.CcrFollowInfoRequest | TB.CcrFollowInfoRequest, options?: TransportRequestOptions): Promise<T.CcrFollowInfoResponse>;
     /**
       * Retrieves follower stats. return shard-level stats about the following tasks associated with each shard for the specified indices.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-get-follow-stats.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-get-follow-stats.html | Elasticsearch API documentation}
       */
     followStats(this: That, params: T.CcrFollowStatsRequest | TB.CcrFollowStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrFollowStatsResponse>;
     followStats(this: That, params: T.CcrFollowStatsRequest | TB.CcrFollowStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrFollowStatsResponse, unknown>>;
     followStats(this: That, params: T.CcrFollowStatsRequest | TB.CcrFollowStatsRequest, options?: TransportRequestOptions): Promise<T.CcrFollowStatsResponse>;
     /**
       * Removes the follower retention leases from the leader.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-post-forget-follower.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-post-forget-follower.html | Elasticsearch API documentation}
       */
     forgetFollower(this: That, params: T.CcrForgetFollowerRequest | TB.CcrForgetFollowerRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrForgetFollowerResponse>;
     forgetFollower(this: That, params: T.CcrForgetFollowerRequest | TB.CcrForgetFollowerRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrForgetFollowerResponse, unknown>>;
     forgetFollower(this: That, params: T.CcrForgetFollowerRequest | TB.CcrForgetFollowerRequest, options?: TransportRequestOptions): Promise<T.CcrForgetFollowerResponse>;
     /**
       * Gets configured auto-follow patterns. Returns the specified auto-follow pattern collection.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-get-auto-follow-pattern.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-get-auto-follow-pattern.html | Elasticsearch API documentation}
       */
     getAutoFollowPattern(this: That, params?: T.CcrGetAutoFollowPatternRequest | TB.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrGetAutoFollowPatternResponse>;
     getAutoFollowPattern(this: That, params?: T.CcrGetAutoFollowPatternRequest | TB.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrGetAutoFollowPatternResponse, unknown>>;
     getAutoFollowPattern(this: That, params?: T.CcrGetAutoFollowPatternRequest | TB.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrGetAutoFollowPatternResponse>;
     /**
       * Pauses an auto-follow pattern
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-pause-auto-follow-pattern.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-pause-auto-follow-pattern.html | Elasticsearch API documentation}
       */
     pauseAutoFollowPattern(this: That, params: T.CcrPauseAutoFollowPatternRequest | TB.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrPauseAutoFollowPatternResponse>;
     pauseAutoFollowPattern(this: That, params: T.CcrPauseAutoFollowPatternRequest | TB.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrPauseAutoFollowPatternResponse, unknown>>;
     pauseAutoFollowPattern(this: That, params: T.CcrPauseAutoFollowPatternRequest | TB.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrPauseAutoFollowPatternResponse>;
     /**
       * Pauses a follower index. The follower index will not fetch any additional operations from the leader index.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-post-pause-follow.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-post-pause-follow.html | Elasticsearch API documentation}
       */
     pauseFollow(this: That, params: T.CcrPauseFollowRequest | TB.CcrPauseFollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrPauseFollowResponse>;
     pauseFollow(this: That, params: T.CcrPauseFollowRequest | TB.CcrPauseFollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrPauseFollowResponse, unknown>>;
     pauseFollow(this: That, params: T.CcrPauseFollowRequest | TB.CcrPauseFollowRequest, options?: TransportRequestOptions): Promise<T.CcrPauseFollowResponse>;
     /**
       * Creates a new named collection of auto-follow patterns against a specified remote cluster. Newly created indices on the remote cluster matching any of the specified patterns will be automatically configured as follower indices.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-put-auto-follow-pattern.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-put-auto-follow-pattern.html | Elasticsearch API documentation}
       */
     putAutoFollowPattern(this: That, params: T.CcrPutAutoFollowPatternRequest | TB.CcrPutAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrPutAutoFollowPatternResponse>;
     putAutoFollowPattern(this: That, params: T.CcrPutAutoFollowPatternRequest | TB.CcrPutAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrPutAutoFollowPatternResponse, unknown>>;
     putAutoFollowPattern(this: That, params: T.CcrPutAutoFollowPatternRequest | TB.CcrPutAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrPutAutoFollowPatternResponse>;
     /**
       * Resumes an auto-follow pattern that has been paused
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-resume-auto-follow-pattern.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-resume-auto-follow-pattern.html | Elasticsearch API documentation}
       */
     resumeAutoFollowPattern(this: That, params: T.CcrResumeAutoFollowPatternRequest | TB.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrResumeAutoFollowPatternResponse>;
     resumeAutoFollowPattern(this: That, params: T.CcrResumeAutoFollowPatternRequest | TB.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrResumeAutoFollowPatternResponse, unknown>>;
     resumeAutoFollowPattern(this: That, params: T.CcrResumeAutoFollowPatternRequest | TB.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptions): Promise<T.CcrResumeAutoFollowPatternResponse>;
     /**
       * Resumes a follower index that has been paused
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-post-resume-follow.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-post-resume-follow.html | Elasticsearch API documentation}
       */
     resumeFollow(this: That, params: T.CcrResumeFollowRequest | TB.CcrResumeFollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrResumeFollowResponse>;
     resumeFollow(this: That, params: T.CcrResumeFollowRequest | TB.CcrResumeFollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrResumeFollowResponse, unknown>>;
     resumeFollow(this: That, params: T.CcrResumeFollowRequest | TB.CcrResumeFollowRequest, options?: TransportRequestOptions): Promise<T.CcrResumeFollowResponse>;
     /**
       * Gets all stats related to cross-cluster replication.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-get-stats.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-get-stats.html | Elasticsearch API documentation}
       */
     stats(this: That, params?: T.CcrStatsRequest | TB.CcrStatsRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrStatsResponse>;
     stats(this: That, params?: T.CcrStatsRequest | TB.CcrStatsRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrStatsResponse, unknown>>;
     stats(this: That, params?: T.CcrStatsRequest | TB.CcrStatsRequest, options?: TransportRequestOptions): Promise<T.CcrStatsResponse>;
     /**
       * Stops the following task associated with a follower index and removes index metadata and settings associated with cross-cluster replication.
-      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/ccr-post-unfollow.html | Elasticsearch API documentation}
+      * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/ccr-post-unfollow.html | Elasticsearch API documentation}
       */
     unfollow(this: That, params: T.CcrUnfollowRequest | TB.CcrUnfollowRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.CcrUnfollowResponse>;
     unfollow(this: That, params: T.CcrUnfollowRequest | TB.CcrUnfollowRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.CcrUnfollowResponse, unknown>>;

package/lib/api/api/clear_scroll.d.ts

@@ -5,8 +5,8 @@ interface That {
     transport: Transport;
 }
 /**
-  * Explicitly clears the search context for a scroll.
-  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.14/clear-scroll-api.html | Elasticsearch API documentation}
+  * Clears the search context and results for a scrolling search.
+  * @see {@link https://www.elastic.co/guide/en/elasticsearch/reference/8.15/clear-scroll-api.html | Elasticsearch API documentation}
   */
 export default function ClearScrollApi(this: That, params?: T.ClearScrollRequest | TB.ClearScrollRequest, options?: TransportRequestOptionsWithOutMeta): Promise<T.ClearScrollResponse>;
 export default function ClearScrollApi(this: That, params?: T.ClearScrollRequest | TB.ClearScrollRequest, options?: TransportRequestOptionsWithMeta): Promise<TransportResult<T.ClearScrollResponse, unknown>>;