Expose the new type definition along with the current one (#1440)

api/kibana.d.ts

@@ -127,7 +127,7 @@ interface KibanaClient {
     getAutoFollowPattern<TContext = unknown>(params?: T.GetAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.GetAutoFollowPatternResponse, TContext>>
     pauseAutoFollowPattern<TContext = unknown>(params: T.PauseAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.PauseAutoFollowPatternResponse, TContext>>
     pauseFollow<TContext = unknown>(params: T.PauseFollowIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.PauseFollowIndexResponse, TContext>>
-    putAutoFollowPattern<TContext = unknown>(params: T.CreateAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CreateAutoFollowPatternResponse, TContext>>
+    putAutoFollowPattern<TContext = unknown>(params: T.PutAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.PutAutoFollowPatternResponse, TContext>>
     resumeAutoFollowPattern<TContext = unknown>(params: T.ResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ResumeAutoFollowPatternResponse, TContext>>
     resumeFollow<TContext = unknown>(params: T.ResumeFollowIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ResumeFollowIndexResponse, TContext>>
     stats<TContext = unknown>(params?: T.CcrStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CcrStatsResponse, TContext>>
@@ -137,7 +137,7 @@ interface KibanaClient {
   closePointInTime<TContext = unknown>(params?: T.ClosePointInTimeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClosePointInTimeResponse, TContext>>
   cluster: {
     allocationExplain<TContext = unknown>(params?: T.ClusterAllocationExplainRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClusterAllocationExplainResponse, TContext>>
-    deleteComponentTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteComponentTemplate<TContext = unknown>(params: T.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClusterDeleteComponentTemplateResponse, TContext>>
     deleteVotingConfigExclusions<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     existsComponentTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     getComponentTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
@@ -181,10 +181,10 @@ interface KibanaClient {
     stats<TContext = unknown>(params?: T.EnrichStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EnrichStatsResponse, TContext>>
   }
   eql: {
-    delete<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    delete<TContext = unknown>(params: T.EqlDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlDeleteResponse, TContext>>
-    get<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    get<TEvent = unknown, TContext = unknown>(params: T.EqlGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlGetResponse<TEvent>, TContext>>
-    getStatus<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getStatus<TContext = unknown>(params: T.EqlGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlGetStatusResponse, TContext>>
-    search<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    search<TEvent = unknown, TContext = unknown>(params: T.EqlSearchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlSearchResponse<TEvent>, TContext>>
   }
   exists<TContext = unknown>(params: T.DocumentExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DocumentExistsResponse, TContext>>
   existsSource<TContext = unknown>(params: T.SourceExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SourceExistsResponse, TContext>>
@@ -215,17 +215,17 @@ interface KibanaClient {
   }
   index<TDocument = unknown, TContext = unknown>(params: T.IndexRequest<TDocument>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndexResponse, TContext>>
   indices: {
-    addBlock<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    addBlock<TContext = unknown>(params: T.IndexAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndexAddBlockResponse, TContext>>
     analyze<TContext = unknown>(params?: T.AnalyzeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.AnalyzeResponse, TContext>>
     clearCache<TContext = unknown>(params?: T.ClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearCacheResponse, TContext>>
     clone<TContext = unknown>(params: T.CloneIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CloneIndexResponse, TContext>>
     close<TContext = unknown>(params: T.CloseIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CloseIndexResponse, TContext>>
     create<TContext = unknown>(params: T.CreateIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CreateIndexResponse, TContext>>
     createDataStream<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
-    dataStreamsStats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    dataStreamsStats<TContext = unknown>(params?: T.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDataStreamsStatsResponse, TContext>>
     delete<TContext = unknown>(params: T.DeleteIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteIndexResponse, TContext>>
     deleteAlias<TContext = unknown>(params: T.DeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteAliasResponse, TContext>>
-    deleteDataStream<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteDataStream<TContext = unknown>(params: T.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDeleteDataStreamResponse, TContext>>
     deleteIndexTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     deleteTemplate<TContext = unknown>(params: T.DeleteIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteIndexTemplateResponse, TContext>>
     exists<TContext = unknown>(params: T.IndexExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndexExistsResponse, TContext>>
@@ -246,7 +246,7 @@ interface KibanaClient {
     getSettings<TContext = unknown>(params?: T.GetIndexSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.GetIndexSettingsResponse, TContext>>
     getTemplate<TContext = unknown>(params?: T.GetIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.GetIndexTemplateResponse, TContext>>
     getUpgrade<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
-    migrateToDataStream<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    migrateToDataStream<TContext = unknown>(params: T.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesMigrateToDataStreamResponse, TContext>>
     open<TContext = unknown>(params: T.OpenIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.OpenIndexResponse, TContext>>
     promoteDataStream<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     putAlias<TContext = unknown>(params: T.PutAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.PutAliasResponse, TContext>>
@@ -257,7 +257,7 @@ interface KibanaClient {
     recovery<TContext = unknown>(params?: T.RecoveryStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.RecoveryStatusResponse, TContext>>
     refresh<TContext = unknown>(params?: T.RefreshRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.RefreshResponse, TContext>>
     reloadSearchAnalyzers<TContext = unknown>(params: T.ReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ReloadSearchAnalyzersResponse, TContext>>
-    resolveIndex<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    resolveIndex<TContext = unknown>(params: T.ResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ResolveIndexResponse, TContext>>
     rollover<TContext = unknown>(params: T.RolloverIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.RolloverIndexResponse, TContext>>
     segments<TContext = unknown>(params?: T.SegmentsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SegmentsResponse, TContext>>
     shardStores<TContext = unknown>(params?: T.IndicesShardStoresRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesShardStoresResponse, TContext>>
@@ -309,8 +309,8 @@ interface KibanaClient {
     deleteForecast<TContext = unknown>(params: T.DeleteForecastRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteForecastResponse, TContext>>
     deleteJob<TContext = unknown>(params: T.DeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteJobResponse, TContext>>
     deleteModelSnapshot<TContext = unknown>(params: T.DeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteModelSnapshotResponse, TContext>>
-    deleteTrainedModel<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteTrainedModel<TContext = unknown>(params: T.DeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteTrainedModelResponse, TContext>>
-    deleteTrainedModelAlias<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteTrainedModelAlias<TContext = unknown>(params: T.DeleteTrainedModelAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteTrainedModelAliasResponse, TContext>>
     estimateModelMemory<TContext = unknown>(params?: T.EstimateModelMemoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EstimateModelMemoryResponse, TContext>>
     evaluateDataFrame<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     explainDataFrameAnalytics<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
@@ -400,7 +400,7 @@ interface KibanaClient {
   searchTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
   searchableSnapshots: {
     clearCache<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
-    mount<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    mount<TContext = unknown>(params: T.SearchableSnapshotsMountRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SearchableSnapshotsMountResponse, TContext>>
     repositoryStats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     stats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
   }
@@ -408,7 +408,7 @@ interface KibanaClient {
     authenticate<TContext = unknown>(params?: T.AuthenticateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.AuthenticateResponse, TContext>>
     changePassword<TContext = unknown>(params?: T.ChangePasswordRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ChangePasswordResponse, TContext>>
     clearApiKeyCache<TContext = unknown>(params?: T.ClearApiKeyCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearApiKeyCacheResponse, TContext>>
-    clearCachedPrivileges<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    clearCachedPrivileges<TContext = unknown>(params: T.ClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearCachedPrivilegesResponse, TContext>>
     clearCachedRealms<TContext = unknown>(params: T.ClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearCachedRealmsResponse, TContext>>
     clearCachedRoles<TContext = unknown>(params: T.ClearCachedRolesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearCachedRolesResponse, TContext>>
     createApiKey<TContext = unknown>(params?: T.CreateApiKeyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CreateApiKeyResponse, TContext>>

api/new.d.ts

@@ -17,14 +17,27 @@
  * under the License.
  */
 
-import * as T from './types'
+/// <reference types="node" />
+
 import {
-  TransportRequestPromise,
+  ClientOptions,
+  ConnectionPool,
+  Serializer,
+  Transport,
+  errors,
+  RequestEvent,
+  ResurrectEvent,
+  ApiError
+} from '../index'
+import Helpers from '../lib/Helpers'
+import {
+  ApiResponse,
   TransportRequestCallback,
-  TransportRequestOptions,
+  TransportRequestPromise,
-  ApiError,
+  TransportRequestParams,
-  ApiResponse
+  TransportRequestOptions
 } from '../lib/Transport'
+import * as T from './types'
 
 /**
   * We are still working on this type, it will arrive soon.
@@ -33,8 +46,41 @@ import {
   */
 type TODO = Record<string, any>
 
+// Extend API
+interface ClientExtendsCallbackOptions {
+  ConfigurationError: errors.ConfigurationError,
+  makeRequest(params: TransportRequestParams, options?: TransportRequestOptions): Promise<void> | void;
+  result: {
+    body: null,
+    statusCode: null,
+    headers: null,
+    warnings: null
+  }
+}
+declare type extendsCallback = (options: ClientExtendsCallbackOptions) => any;
+// /Extend API
+
 declare type callbackFn<TResponse, TContext> = (err: ApiError, result: ApiResponse<TResponse, TContext>) => void;
-declare class ESAPI {
+interface NewClientTypes {
+  connectionPool: ConnectionPool
+  transport: Transport
+  serializer: Serializer
+  extend(method: string, fn: extendsCallback): void
+  extend(method: string, opts: { force: boolean }, fn: extendsCallback): void;
+  helpers: Helpers
+  child(opts?: ClientOptions): NewClientTypes
+  close(callback: Function): void;
+  close(): Promise<void>;
+  emit(event: string | symbol, ...args: any[]): boolean;
+  on(event: 'request', listener: (err: ApiError, meta: RequestEvent) => void): this;
+  on(event: 'response', listener: (err: ApiError, meta: RequestEvent) => void): this;
+  on(event: 'sniff', listener: (err: ApiError, meta: RequestEvent) => void): this;
+  on(event: 'resurrect', listener: (err: null, meta: ResurrectEvent) => void): this;
+  once(event: 'request', listener: (err: ApiError, meta: RequestEvent) => void): this;
+  once(event: 'response', listener: (err: ApiError, meta: RequestEvent) => void): this;
+  once(event: 'sniff', listener: (err: ApiError, meta: RequestEvent) => void): this;
+  once(event: 'resurrect', listener: (err: null, meta: ResurrectEvent) => void): this;
+  off(event: string | symbol, listener: (...args: any[]) => void): this;
   asyncSearch: {
     delete<TContext = unknown>(params: T.AsyncSearchDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.AsyncSearchDeleteResponse, TContext>>
     delete<TContext = unknown>(params: T.AsyncSearchDeleteRequest, callback: callbackFn<T.AsyncSearchDeleteResponse, TContext>): TransportRequestCallback
@@ -199,9 +245,9 @@ declare class ESAPI {
     pauseFollow<TContext = unknown>(params: T.PauseFollowIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.PauseFollowIndexResponse, TContext>>
     pauseFollow<TContext = unknown>(params: T.PauseFollowIndexRequest, callback: callbackFn<T.PauseFollowIndexResponse, TContext>): TransportRequestCallback
     pauseFollow<TContext = unknown>(params: T.PauseFollowIndexRequest, options: TransportRequestOptions, callback: callbackFn<T.PauseFollowIndexResponse, TContext>): TransportRequestCallback
-    putAutoFollowPattern<TContext = unknown>(params: T.CreateAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.CreateAutoFollowPatternResponse, TContext>>
+    putAutoFollowPattern<TContext = unknown>(params: T.PutAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.PutAutoFollowPatternResponse, TContext>>
-    putAutoFollowPattern<TContext = unknown>(params: T.CreateAutoFollowPatternRequest, callback: callbackFn<T.CreateAutoFollowPatternResponse, TContext>): TransportRequestCallback
+    putAutoFollowPattern<TContext = unknown>(params: T.PutAutoFollowPatternRequest, callback: callbackFn<T.PutAutoFollowPatternResponse, TContext>): TransportRequestCallback
-    putAutoFollowPattern<TContext = unknown>(params: T.CreateAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<T.CreateAutoFollowPatternResponse, TContext>): TransportRequestCallback
+    putAutoFollowPattern<TContext = unknown>(params: T.PutAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<T.PutAutoFollowPatternResponse, TContext>): TransportRequestCallback
     resumeAutoFollowPattern<TContext = unknown>(params: T.ResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ResumeAutoFollowPatternResponse, TContext>>
     resumeAutoFollowPattern<TContext = unknown>(params: T.ResumeAutoFollowPatternRequest, callback: callbackFn<T.ResumeAutoFollowPatternResponse, TContext>): TransportRequestCallback
     resumeAutoFollowPattern<TContext = unknown>(params: T.ResumeAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<T.ResumeAutoFollowPatternResponse, TContext>): TransportRequestCallback
@@ -229,10 +275,9 @@ declare class ESAPI {
     allocationExplain<TContext = unknown>(callback: callbackFn<T.ClusterAllocationExplainResponse, TContext>): TransportRequestCallback
     allocationExplain<TContext = unknown>(params: T.ClusterAllocationExplainRequest, callback: callbackFn<T.ClusterAllocationExplainResponse, TContext>): TransportRequestCallback
     allocationExplain<TContext = unknown>(params: T.ClusterAllocationExplainRequest, options: TransportRequestOptions, callback: callbackFn<T.ClusterAllocationExplainResponse, TContext>): TransportRequestCallback
-    deleteComponentTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteComponentTemplate<TContext = unknown>(params: T.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClusterDeleteComponentTemplateResponse, TContext>>
-    deleteComponentTemplate<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteComponentTemplate<TContext = unknown>(params: T.ClusterDeleteComponentTemplateRequest, callback: callbackFn<T.ClusterDeleteComponentTemplateResponse, TContext>): TransportRequestCallback
-    deleteComponentTemplate<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteComponentTemplate<TContext = unknown>(params: T.ClusterDeleteComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<T.ClusterDeleteComponentTemplateResponse, TContext>): TransportRequestCallback
-    deleteComponentTemplate<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     deleteVotingConfigExclusions<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     deleteVotingConfigExclusions<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     deleteVotingConfigExclusions<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
@@ -373,22 +418,18 @@ declare class ESAPI {
     stats<TContext = unknown>(params: T.EnrichStatsRequest, options: TransportRequestOptions, callback: callbackFn<T.EnrichStatsResponse, TContext>): TransportRequestCallback
   }
   eql: {
-    delete<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    delete<TContext = unknown>(params: T.EqlDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlDeleteResponse, TContext>>
-    delete<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    delete<TContext = unknown>(params: T.EqlDeleteRequest, callback: callbackFn<T.EqlDeleteResponse, TContext>): TransportRequestCallback
-    delete<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    delete<TContext = unknown>(params: T.EqlDeleteRequest, options: TransportRequestOptions, callback: callbackFn<T.EqlDeleteResponse, TContext>): TransportRequestCallback
-    delete<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    get<TEvent = unknown, TContext = unknown>(params: T.EqlGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlGetResponse<TEvent>, TContext>>
-    get<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    get<TEvent = unknown, TContext = unknown>(params: T.EqlGetRequest, callback: callbackFn<T.EqlGetResponse<TEvent>, TContext>): TransportRequestCallback
-    get<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    get<TEvent = unknown, TContext = unknown>(params: T.EqlGetRequest, options: TransportRequestOptions, callback: callbackFn<T.EqlGetResponse<TEvent>, TContext>): TransportRequestCallback
-    get<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getStatus<TContext = unknown>(params: T.EqlGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlGetStatusResponse, TContext>>
-    get<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    getStatus<TContext = unknown>(params: T.EqlGetStatusRequest, callback: callbackFn<T.EqlGetStatusResponse, TContext>): TransportRequestCallback
-    getStatus<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    getStatus<TContext = unknown>(params: T.EqlGetStatusRequest, options: TransportRequestOptions, callback: callbackFn<T.EqlGetStatusResponse, TContext>): TransportRequestCallback
-    getStatus<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    search<TEvent = unknown, TContext = unknown>(params: T.EqlSearchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EqlSearchResponse<TEvent>, TContext>>
-    getStatus<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    search<TEvent = unknown, TContext = unknown>(params: T.EqlSearchRequest, callback: callbackFn<T.EqlSearchResponse<TEvent>, TContext>): TransportRequestCallback
-    getStatus<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    search<TEvent = unknown, TContext = unknown>(params: T.EqlSearchRequest, options: TransportRequestOptions, callback: callbackFn<T.EqlSearchResponse<TEvent>, TContext>): TransportRequestCallback
-    search<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
-    search<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    search<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    search<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
   }
   exists<TContext = unknown>(params: T.DocumentExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DocumentExistsResponse, TContext>>
   exists<TContext = unknown>(params: T.DocumentExistsRequest, callback: callbackFn<T.DocumentExistsResponse, TContext>): TransportRequestCallback
@@ -472,10 +513,9 @@ declare class ESAPI {
   index<TDocument = unknown, TContext = unknown>(params: T.IndexRequest<TDocument>, callback: callbackFn<T.IndexResponse, TContext>): TransportRequestCallback
   index<TDocument = unknown, TContext = unknown>(params: T.IndexRequest<TDocument>, options: TransportRequestOptions, callback: callbackFn<T.IndexResponse, TContext>): TransportRequestCallback
   indices: {
-    addBlock<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    addBlock<TContext = unknown>(params: T.IndexAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndexAddBlockResponse, TContext>>
-    addBlock<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    addBlock<TContext = unknown>(params: T.IndexAddBlockRequest, callback: callbackFn<T.IndexAddBlockResponse, TContext>): TransportRequestCallback
-    addBlock<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    addBlock<TContext = unknown>(params: T.IndexAddBlockRequest, options: TransportRequestOptions, callback: callbackFn<T.IndexAddBlockResponse, TContext>): TransportRequestCallback
-    addBlock<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     analyze<TContext = unknown>(params?: T.AnalyzeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.AnalyzeResponse, TContext>>
     analyze<TContext = unknown>(callback: callbackFn<T.AnalyzeResponse, TContext>): TransportRequestCallback
     analyze<TContext = unknown>(params: T.AnalyzeRequest, callback: callbackFn<T.AnalyzeResponse, TContext>): TransportRequestCallback
@@ -497,20 +537,19 @@ declare class ESAPI {
     createDataStream<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     createDataStream<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     createDataStream<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    dataStreamsStats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    dataStreamsStats<TContext = unknown>(params?: T.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDataStreamsStatsResponse, TContext>>
-    dataStreamsStats<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    dataStreamsStats<TContext = unknown>(callback: callbackFn<T.IndicesDataStreamsStatsResponse, TContext>): TransportRequestCallback
-    dataStreamsStats<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    dataStreamsStats<TContext = unknown>(params: T.IndicesDataStreamsStatsRequest, callback: callbackFn<T.IndicesDataStreamsStatsResponse, TContext>): TransportRequestCallback
-    dataStreamsStats<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    dataStreamsStats<TContext = unknown>(params: T.IndicesDataStreamsStatsRequest, options: TransportRequestOptions, callback: callbackFn<T.IndicesDataStreamsStatsResponse, TContext>): TransportRequestCallback
     delete<TContext = unknown>(params: T.DeleteIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteIndexResponse, TContext>>
     delete<TContext = unknown>(params: T.DeleteIndexRequest, callback: callbackFn<T.DeleteIndexResponse, TContext>): TransportRequestCallback
     delete<TContext = unknown>(params: T.DeleteIndexRequest, options: TransportRequestOptions, callback: callbackFn<T.DeleteIndexResponse, TContext>): TransportRequestCallback
     deleteAlias<TContext = unknown>(params: T.DeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteAliasResponse, TContext>>
     deleteAlias<TContext = unknown>(params: T.DeleteAliasRequest, callback: callbackFn<T.DeleteAliasResponse, TContext>): TransportRequestCallback
     deleteAlias<TContext = unknown>(params: T.DeleteAliasRequest, options: TransportRequestOptions, callback: callbackFn<T.DeleteAliasResponse, TContext>): TransportRequestCallback
-    deleteDataStream<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteDataStream<TContext = unknown>(params: T.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesDeleteDataStreamResponse, TContext>>
-    deleteDataStream<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteDataStream<TContext = unknown>(params: T.IndicesDeleteDataStreamRequest, callback: callbackFn<T.IndicesDeleteDataStreamResponse, TContext>): TransportRequestCallback
-    deleteDataStream<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteDataStream<TContext = unknown>(params: T.IndicesDeleteDataStreamRequest, options: TransportRequestOptions, callback: callbackFn<T.IndicesDeleteDataStreamResponse, TContext>): TransportRequestCallback
-    deleteDataStream<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     deleteIndexTemplate<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     deleteIndexTemplate<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     deleteIndexTemplate<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
@@ -583,10 +622,9 @@ declare class ESAPI {
     getUpgrade<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     getUpgrade<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     getUpgrade<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    migrateToDataStream<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    migrateToDataStream<TContext = unknown>(params: T.IndicesMigrateToDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.IndicesMigrateToDataStreamResponse, TContext>>
-    migrateToDataStream<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    migrateToDataStream<TContext = unknown>(params: T.IndicesMigrateToDataStreamRequest, callback: callbackFn<T.IndicesMigrateToDataStreamResponse, TContext>): TransportRequestCallback
-    migrateToDataStream<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    migrateToDataStream<TContext = unknown>(params: T.IndicesMigrateToDataStreamRequest, options: TransportRequestOptions, callback: callbackFn<T.IndicesMigrateToDataStreamResponse, TContext>): TransportRequestCallback
-    migrateToDataStream<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     open<TContext = unknown>(params: T.OpenIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.OpenIndexResponse, TContext>>
     open<TContext = unknown>(params: T.OpenIndexRequest, callback: callbackFn<T.OpenIndexResponse, TContext>): TransportRequestCallback
     open<TContext = unknown>(params: T.OpenIndexRequest, options: TransportRequestOptions, callback: callbackFn<T.OpenIndexResponse, TContext>): TransportRequestCallback
@@ -623,10 +661,9 @@ declare class ESAPI {
     reloadSearchAnalyzers<TContext = unknown>(params: T.ReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ReloadSearchAnalyzersResponse, TContext>>
     reloadSearchAnalyzers<TContext = unknown>(params: T.ReloadSearchAnalyzersRequest, callback: callbackFn<T.ReloadSearchAnalyzersResponse, TContext>): TransportRequestCallback
     reloadSearchAnalyzers<TContext = unknown>(params: T.ReloadSearchAnalyzersRequest, options: TransportRequestOptions, callback: callbackFn<T.ReloadSearchAnalyzersResponse, TContext>): TransportRequestCallback
-    resolveIndex<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    resolveIndex<TContext = unknown>(params: T.ResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ResolveIndexResponse, TContext>>
-    resolveIndex<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    resolveIndex<TContext = unknown>(params: T.ResolveIndexRequest, callback: callbackFn<T.ResolveIndexResponse, TContext>): TransportRequestCallback
-    resolveIndex<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    resolveIndex<TContext = unknown>(params: T.ResolveIndexRequest, options: TransportRequestOptions, callback: callbackFn<T.ResolveIndexResponse, TContext>): TransportRequestCallback
-    resolveIndex<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     rollover<TContext = unknown>(params: T.RolloverIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.RolloverIndexResponse, TContext>>
     rollover<TContext = unknown>(params: T.RolloverIndexRequest, callback: callbackFn<T.RolloverIndexResponse, TContext>): TransportRequestCallback
     rollover<TContext = unknown>(params: T.RolloverIndexRequest, options: TransportRequestOptions, callback: callbackFn<T.RolloverIndexResponse, TContext>): TransportRequestCallback
@@ -786,14 +823,12 @@ declare class ESAPI {
     deleteModelSnapshot<TContext = unknown>(params: T.DeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteModelSnapshotResponse, TContext>>
     deleteModelSnapshot<TContext = unknown>(params: T.DeleteModelSnapshotRequest, callback: callbackFn<T.DeleteModelSnapshotResponse, TContext>): TransportRequestCallback
     deleteModelSnapshot<TContext = unknown>(params: T.DeleteModelSnapshotRequest, options: TransportRequestOptions, callback: callbackFn<T.DeleteModelSnapshotResponse, TContext>): TransportRequestCallback
-    deleteTrainedModel<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteTrainedModel<TContext = unknown>(params: T.DeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteTrainedModelResponse, TContext>>
-    deleteTrainedModel<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteTrainedModel<TContext = unknown>(params: T.DeleteTrainedModelRequest, callback: callbackFn<T.DeleteTrainedModelResponse, TContext>): TransportRequestCallback
-    deleteTrainedModel<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteTrainedModel<TContext = unknown>(params: T.DeleteTrainedModelRequest, options: TransportRequestOptions, callback: callbackFn<T.DeleteTrainedModelResponse, TContext>): TransportRequestCallback
-    deleteTrainedModel<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteTrainedModelAlias<TContext = unknown>(params: T.DeleteTrainedModelAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.DeleteTrainedModelAliasResponse, TContext>>
-    deleteTrainedModelAlias<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    deleteTrainedModelAlias<TContext = unknown>(params: T.DeleteTrainedModelAliasRequest, callback: callbackFn<T.DeleteTrainedModelAliasResponse, TContext>): TransportRequestCallback
-    deleteTrainedModelAlias<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    deleteTrainedModelAlias<TContext = unknown>(params: T.DeleteTrainedModelAliasRequest, options: TransportRequestOptions, callback: callbackFn<T.DeleteTrainedModelAliasResponse, TContext>): TransportRequestCallback
-    deleteTrainedModelAlias<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    deleteTrainedModelAlias<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     estimateModelMemory<TContext = unknown>(params?: T.EstimateModelMemoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.EstimateModelMemoryResponse, TContext>>
     estimateModelMemory<TContext = unknown>(callback: callbackFn<T.EstimateModelMemoryResponse, TContext>): TransportRequestCallback
     estimateModelMemory<TContext = unknown>(params: T.EstimateModelMemoryRequest, callback: callbackFn<T.EstimateModelMemoryResponse, TContext>): TransportRequestCallback
@@ -1092,10 +1127,9 @@ declare class ESAPI {
     clearCache<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     clearCache<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     clearCache<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
-    mount<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    mount<TContext = unknown>(params: T.SearchableSnapshotsMountRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.SearchableSnapshotsMountResponse, TContext>>
-    mount<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    mount<TContext = unknown>(params: T.SearchableSnapshotsMountRequest, callback: callbackFn<T.SearchableSnapshotsMountResponse, TContext>): TransportRequestCallback
-    mount<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    mount<TContext = unknown>(params: T.SearchableSnapshotsMountRequest, options: TransportRequestOptions, callback: callbackFn<T.SearchableSnapshotsMountResponse, TContext>): TransportRequestCallback
-    mount<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     repositoryStats<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
     repositoryStats<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
     repositoryStats<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
@@ -1118,10 +1152,9 @@ declare class ESAPI {
     clearApiKeyCache<TContext = unknown>(callback: callbackFn<T.ClearApiKeyCacheResponse, TContext>): TransportRequestCallback
     clearApiKeyCache<TContext = unknown>(params: T.ClearApiKeyCacheRequest, callback: callbackFn<T.ClearApiKeyCacheResponse, TContext>): TransportRequestCallback
     clearApiKeyCache<TContext = unknown>(params: T.ClearApiKeyCacheRequest, options: TransportRequestOptions, callback: callbackFn<T.ClearApiKeyCacheResponse, TContext>): TransportRequestCallback
-    clearCachedPrivileges<TContext = unknown>(params?: TODO, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TODO, TContext>>
+    clearCachedPrivileges<TContext = unknown>(params: T.ClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearCachedPrivilegesResponse, TContext>>
-    clearCachedPrivileges<TContext = unknown>(callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    clearCachedPrivileges<TContext = unknown>(params: T.ClearCachedPrivilegesRequest, callback: callbackFn<T.ClearCachedPrivilegesResponse, TContext>): TransportRequestCallback
-    clearCachedPrivileges<TContext = unknown>(params: TODO, callback: callbackFn<TODO, TContext>): TransportRequestCallback
+    clearCachedPrivileges<TContext = unknown>(params: T.ClearCachedPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<T.ClearCachedPrivilegesResponse, TContext>): TransportRequestCallback
-    clearCachedPrivileges<TContext = unknown>(params: TODO, options: TransportRequestOptions, callback: callbackFn<TODO, TContext>): TransportRequestCallback
     clearCachedRealms<TContext = unknown>(params: T.ClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<T.ClearCachedRealmsResponse, TContext>>
     clearCachedRealms<TContext = unknown>(params: T.ClearCachedRealmsRequest, callback: callbackFn<T.ClearCachedRealmsResponse, TContext>): TransportRequestCallback
     clearCachedRealms<TContext = unknown>(params: T.ClearCachedRealmsRequest, options: TransportRequestOptions, callback: callbackFn<T.ClearCachedRealmsResponse, TContext>): TransportRequestCallback
@@ -1415,4 +1448,4 @@ declare class ESAPI {
   }
 }
 
-export default ESAPI
+export { NewClientTypes }

api/requestParams.d.ts

@@ -563,8 +563,8 @@ export interface ClusterReroute<T = RequestBody> extends Generic {
 }
 
 export interface ClusterState extends Generic {
-  metric?: string | string[];
   index?: string | string[];
+  metric?: string | string[];
   local?: boolean;
   master_timeout?: string;
   flat_settings?: boolean;
@@ -1394,6 +1394,9 @@ export interface IngestDeletePipeline extends Generic {
   timeout?: string;
 }
 
+export interface IngestGeoIpStats extends Generic {
+}
+
 export interface IngestGetPipeline extends Generic {
   id?: string;
   summary?: boolean;
@@ -1759,8 +1762,9 @@ export interface MlPreviewDataFrameAnalytics<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlPreviewDatafeed extends Generic {
+export interface MlPreviewDatafeed<T = RequestBody> extends Generic {
-  datafeed_id: string;
+  datafeed_id?: string;
+  body?: T;
 }
 
 export interface MlPutCalendar<T = RequestBody> extends Generic {
@@ -2338,6 +2342,19 @@ export interface SecurityPutUser<T = RequestBody> extends Generic {
   body: T;
 }
 
+export interface ShutdownDeleteNode extends Generic {
+  node_id: string;
+}
+
+export interface ShutdownGetNode extends Generic {
+  node_id?: string;
+}
+
+export interface ShutdownPutNode<T = RequestBody> extends Generic {
+  node_id: string;
+  body: T;
+}
+
 export interface SlmDeleteLifecycle extends Generic {
   policy_id: string;
 }

docs/typescript.asciidoc

@@ -1,12 +1,107 @@
 [[typescript]]
 === TypeScript support
 
-The client offers a first-class support for TypeScript, since it ships the type 
+The client offers a first-class support for TypeScript, shipping a complete set
-definitions for every exposed API.
+of type definitions of Elasticsearch's API surface.
+
 
 NOTE: If you are using TypeScript you need to use _snake_case_ style to define 
 the API parameters instead of _camelCase_. 
 
+Currently the client exposes two type definitions, the legacy one, which is the default
+and the new one, which will be the default in the next major.
+We strongly recommend to migrate to the new one as soon as possible, as the new types
+are offering a vastly improved developer experience and guarantee you that your code
+will always be in sync with the latest Elasticsearch features.
+
+[discrete]
+==== New type definitions
+
+The new type definition is more advanced compared to the legacy one. In the legacy
+type definitions you were expected to configure via generics both request and response
+bodies. The new type definitions comes with a complete type definition for every
+Elasticsearch endpoint.
+
+For example:
+
+[source,ts]
+----
+// legacy definitions
+const response = await client.search<SearchResponse<Source>, SearchBody>({
+  index: 'test',
+  body: {
+  query: {
+      match: { foo: 'bar' }
+    }
+  }
+})
+
+// new definitions
+const response = await client.search<Source>({
+  index: 'test',
+  body: {
+  query: {
+      match: { foo: 'bar' }
+    }
+  }
+})
+----
+
+The types are not 100% complete yet. Some APIs are missing (the newest ones, e.g. EQL),
+and others may contain some errors, but we are continuously pushing fixes & improvements.
+
+Once you migrate to the new types, those are automatically integrated into the Elasticsearch client, you will get them out of the box.
+If everything works, meaning that you won’t get compiler errors, you are good to go!
+The types are already correct, and there is nothing more to do.
+
+If a type is incorrect, you should add a comment `// @ts-expect-error @elastic/elasticsearch`
+telling TypeScript that you are aware of the warning and you would like to temporarily suppress it.
+In this way, your code will compile until the type is fixed, and when it happens, you’ll only need to remove the
+`// @ts-expect-error @elastic/elasticsearch` comment (TypeScript will let you know when it is time).
+Finally, if the type you need is missing, you’ll see that the client method returns (or defines as a parameter)
+a `TODO` type, which accepts any object.
+
+Open an issue in the client repository letting us know if you encounter any problem!
+
+[discrete]
+===== How to migrate to the new type definitions
+
+Since the new type definitions can be considered a breaking change we couldn't add the directly to the client.
+Following you will find a snippet that shows you how to override the default types with the new ones.
+
+[source,ts]
+----
+import { Client } from '@elastic/elasticsearch'
+import type { NewClientTypes } from '@elastic/elasticsearch/api/new'
+
+// @ts-expect-error @elastic/elasticsearch
+const client = new Client({
+  node: 'http://localhost:9200'
+}) as NewClientTypes
+
+interface Source {
+  foo: string
+}
+
+// try the new code completion when building a query!
+const response = await client.search<Source>({
+  index: 'test',
+  body: {
+    query: {
+      match_all: {}
+    }
+  }
+})
+
+// try the new code completion when traversing a response!
+const results = response.body.hits.hits.map(hit => hit._source)
+// results type will be `Source[]`
+console.log(results)
+----
+
+[discrete]
+==== Legacy type definitions
+
 By default event API uses 
 https://www.typescriptlang.org/docs/handbook/generics.html[generics] to specify 
 the requests and response bodies and the `meta.context`. Currently, we can't 
@@ -45,7 +140,7 @@ You don't have to specify all the generics, but the order must be respected.
 
 
 [discrete]
-==== A complete example
+===== A complete example
 
 [source,ts]
 ----

scripts/download-artifacts.js

@@ -1,3 +1,22 @@
+/*
+ * 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.
+ */
+
 'use strict'
 
 const { join } = require('path')

scripts/generate.js

@@ -20,85 +20,98 @@
 'use strict'
 
 const { join } = require('path')
-const { readdirSync, readFileSync, writeFileSync } = require('fs')
+const { readdirSync, writeFileSync, readFileSync } = require('fs')
 const minimist = require('minimist')
-const semver = require('semver')
 const ora = require('ora')
 const rimraf = require('rimraf')
 const standard = require('standard')
+const downloadArtifacts = require('./download-artifacts')
 const {
   generate,
-  cloneAndCheckout,
   genFactory,
-  generateDocs
+  generateDocs,
+  generateRequestTypes
 } = require('./utils')
 
 start(minimist(process.argv.slice(2), {
-  string: ['tag', 'branch']
+  string: ['version', 'hash']
 }))
 
 function start (opts) {
-  const log = ora('Loading Elasticsearch Repository').start()
+  if (opts.version == null) {
-  if (opts.branch == null && semver.valid(opts.tag) === null) {
+    console.error('Missing version parameter')
-    log.fail(`Missing or invalid tag: ${opts.tag}`)
+    process.exit(1)
-    return
   }
+
   const packageFolder = join(__dirname, '..', 'api')
   const apiOutputFolder = join(packageFolder, 'api')
   const mainOutputFile = join(packageFolder, 'index.js')
   const docOutputFile = join(__dirname, '..', 'docs', 'reference.asciidoc')
+  const typeDefFile = join(__dirname, '..', 'index.d.ts')
+  const requestParamsOutputFile = join(packageFolder, 'requestParams.d.ts')
 
-  log.text = 'Cleaning API folder...'
+  let log
-  rimraf.sync(join(apiOutputFolder, '*.js'))
+  downloadArtifacts({ version: opts.version, hash: opts.hash })
+    .then(onArtifactsDownloaded)
+    .catch(err => {
+      console.log(err)
+      process.exit(1)
+    })
 
-  cloneAndCheckout({ log, tag: opts.tag, branch: opts.branch }, (err, { apiFolder, xPackFolder }) => {
+  function onArtifactsDownloaded () {
-    if (err) {
+    log = ora('Generating APIs').start()
-      log.fail(err.message)
-      return
-    }
 
-    const apiFolderContents = readdirSync(apiFolder)
+    log.text = 'Cleaning API folder...'
-    const xPackFolderContents = readdirSync(xPackFolder)
+    rimraf.sync(join(apiOutputFolder, '*.js'))
-      .filter(file => !file.startsWith('data_frame_transform_deprecated'))
 
-    const allSpec = apiFolderContents.concat(xPackFolderContents)
+    const allSpec = readdirSync(downloadArtifacts.locations.specFolder)
       .filter(file => file !== '_common.json')
       .filter(file => !file.includes('deprecated'))
       .sort()
-      .map(file => {
+      .map(file => require(join(downloadArtifacts.locations.specFolder, file)))
-        try {
-          return JSON.parse(readFileSync(join(apiFolder, file), 'utf8'))
-        } catch (err) {
-          return JSON.parse(readFileSync(join(xPackFolder, file), 'utf8'))
-        }
-      })
 
-    const namespaces = namespacify(apiFolderContents.concat(xPackFolderContents))
+    const namespaces = namespacify(readdirSync(downloadArtifacts.locations.specFolder))
     for (const namespace in namespaces) {
       if (namespace === '_common') continue
-      const code = generate(namespace, namespaces[namespace], { apiFolder, xPackFolder }, opts.branch || opts.tag)
+      const code = generate(namespace, namespaces[namespace], downloadArtifacts.locations.specFolder, opts.version)
       const filePath = join(apiOutputFolder, `${namespace}.js`)
       writeFileSync(filePath, code, { encoding: 'utf8' })
     }
 
-    const { fn: factory } = genFactory(apiOutputFolder, [apiFolder, xPackFolder], namespaces)
+    writeFileSync(
+      requestParamsOutputFile,
+      generateRequestTypes(opts.version, allSpec),
+      { encoding: 'utf8' }
+    )
+
+    const { fn: factory, types } = genFactory(apiOutputFolder, downloadArtifacts.locations.specFolder, namespaces)
     writeFileSync(
       mainOutputFile,
       factory,
       { encoding: 'utf8' }
     )
 
+    const oldTypeDefString = readFileSync(typeDefFile, 'utf8')
+    const start = oldTypeDefString.indexOf('/* GENERATED */')
+    const end = oldTypeDefString.indexOf('/* /GENERATED */')
+    const newTypeDefString = oldTypeDefString.slice(0, start + 15) + '\n' + types + '\n  ' + oldTypeDefString.slice(end)
+    writeFileSync(
+      typeDefFile,
+      newTypeDefString,
+      { encoding: 'utf8' }
+    )
+
     lintFiles(log, () => {
       log.text = 'Generating documentation'
       writeFileSync(
         docOutputFile,
-        generateDocs(require(join(apiFolder, '_common.json')), allSpec),
+        generateDocs(require(join(downloadArtifacts.locations.specFolder, '_common.json')), allSpec),
         { encoding: 'utf8' }
       )
 
       log.succeed('Done!')
     })
-  })
+  }
 
   function lintFiles (log, cb) {
     log.text = 'Linting...'

scripts/release-canary.js

@@ -30,6 +30,7 @@ async function release (opts) {
   const originalName = packageJson.name
   const originalVersion = packageJson.version
   const currentCanaryVersion = packageJson.versionCanary
+  const originalTypes = packageJson.types
   const originalNpmIgnore = await readFile(join(__dirname, '..', '.npmignore'), 'utf8')
 
   const newCanaryInteger = opts.reset ? 1 : (Number(currentCanaryVersion.split('-')[1].split('.')[1]) + 1)
@@ -39,12 +40,13 @@ async function release (opts) {
   packageJson.name = '@elastic/elasticsearch-canary'
   packageJson.version = newCanaryVersion
   packageJson.versionCanary = newCanaryVersion
+  packageJson.types = './api/new.d.ts'
   packageJson.commitHash = execSync('git log -1 --pretty=format:%h').toString()
 
   // update the package.json
   await writeFile(
     join(__dirname, '..', 'package.json'),
-    JSON.stringify(packageJson, null, 2),
+    JSON.stringify(packageJson, null, 2) + '\n',
     'utf8'
   )
 
@@ -72,11 +74,12 @@ async function release (opts) {
   // restore the package.json to the original values
   packageJson.name = originalName
   packageJson.version = originalVersion
+  packageJson.types = originalTypes
   delete packageJson.commitHash
 
   await writeFile(
     join(__dirname, '..', 'package.json'),
-    JSON.stringify(packageJson, null, 2),
+    JSON.stringify(packageJson, null, 2) + '\n',
     'utf8'
   )
 

scripts/utils/generateApis.js

@@ -25,7 +25,6 @@
 
 const { join } = require('path')
 const dedent = require('dedent')
-const semver = require('semver')
 const allowedMethods = {
   noBody: ['GET', 'HEAD', 'DELETE'],
   body: ['POST', 'PUT', 'DELETE']
@@ -71,8 +70,8 @@ const ndjsonApi = [
   'xpack.monitoring.bulk'
 ]
 
-function generateNamespace (namespace, nested, folders, version) {
+function generateNamespace (namespace, nested, specFolder, version) {
-  const common = require(join(folders.apiFolder, '_common.json'))
+  const common = require(join(specFolder, '_common.json'))
   let code = dedent`
   /*
    * Licensed to Elasticsearch B.V. under one or more contributor
@@ -110,7 +109,7 @@ function generateNamespace (namespace, nested, folders, version) {
         getters += `${n}: { get () { return this.${nameSnaked} } },\n`
       }
     }
-    const api = generateMultiApi(version, namespace, nested, common, folders)
+    const api = generateMultiApi(version, namespace, nested, common, specFolder)
     if (getters.length > 0) {
       getters = `Object.defineProperties(${api.namespace}Api.prototype, {\n${getters}})`
     }
@@ -131,12 +130,7 @@ function generateNamespace (namespace, nested, folders, version) {
   module.exports = ${api.namespace}Api
     `
   } else {
-    let spec = null
+    const spec = require(join(specFolder, `${namespace}.json`))
-    try {
-      spec = require(join(folders.apiFolder, `${namespace}.json`))
-    } catch (err) {
-      spec = require(join(folders.xPackFolder, `${namespace}.json`))
-    }
     const api = generateSingleApi(version, spec, common)
     code += `
   const acceptedQuerystring = ${JSON.stringify(api.acceptedQuerystring)}
@@ -150,7 +144,7 @@ function generateNamespace (namespace, nested, folders, version) {
   return code
 }
 
-function generateMultiApi (version, namespace, nested, common, folders) {
+function generateMultiApi (version, namespace, nested, common, specFolder) {
   const namespaceSnaked = namespace
     .replace(/\.([a-z])/g, k => k[1].toUpperCase())
     .replace(/_([a-z])/g, k => k[1].toUpperCase())
@@ -158,15 +152,10 @@ function generateMultiApi (version, namespace, nested, common, folders) {
   const snakeCase = {}
   const acceptedQuerystring = []
   for (const n of nested) {
-    let spec = null
     const nameSnaked = n
       .replace(/\.([a-z])/g, k => k[1].toUpperCase())
       .replace(/_([a-z])/g, k => k[1].toUpperCase())
-    try {
+    const spec = require(join(specFolder, `${namespace}.${n}.json`))
-      spec = require(join(folders.apiFolder, `${namespace}.${n}.json`))
-    } catch (err) {
-      spec = require(join(folders.xPackFolder, `${namespace}.${n}.json`))
-    }
     const api = generateSingleApi(version, spec, common)
     code += `${Uppercase(namespaceSnaked)}Api.prototype.${nameSnaked} = ${api.code}\n\n`
     Object.assign(snakeCase, api.snakeCase)
@@ -180,7 +169,7 @@ function generateMultiApi (version, namespace, nested, common, folders) {
 }
 
 function generateSingleApi (version, spec, common) {
-  const release = semver.valid(version) ? semver.major(version) : version
+  const release = version.charAt(0)
   const api = Object.keys(spec)[0]
   const name = api
     .replace(/\.([a-z])/g, k => k[1].toUpperCase())

scripts/utils/generateMain.js

@@ -35,11 +35,10 @@ const ndjsonApiKey = ndjsonApi
   })
   .map(toPascalCase)
 
-function genFactory (folder, paths, namespaces) {
+function genFactory (folder, specFolder, namespaces) {
   // get all the API files
   // const apiFiles = readdirSync(folder)
-  const apiFiles = readdirSync(paths[0])
+  const apiFiles = readdirSync(specFolder)
-    .concat(readdirSync(paths[1]))
     .filter(file => file !== '_common.json')
     .filter(file => !file.includes('deprecated'))
     .sort()
@@ -55,7 +54,7 @@ function genFactory (folder, paths, namespaces) {
         .split('.')
         .reverse()
         .reduce((acc, val) => {
-          const spec = readSpec(paths, file.slice(0, -5))
+          const spec = readSpec(specFolder, file.slice(0, -5))
           const isHead = isHeadMethod(spec, file.slice(0, -5))
           const body = hasBody(spec, file.slice(0, -5))
           const methods = acc === null ? buildMethodDefinition({ kibana: false }, val, name, body, isHead) : null
@@ -87,7 +86,7 @@ function genFactory (folder, paths, namespaces) {
         .split('.')
         .reverse()
         .reduce((acc, val) => {
-          const spec = readSpec(paths, file.slice(0, -5))
+          const spec = readSpec(specFolder, file.slice(0, -5))
           const isHead = isHeadMethod(spec, file.slice(0, -5))
           const body = hasBody(spec, file.slice(0, -5))
           const methods = acc === null ? buildMethodDefinition({ kibana: true }, val, name, body, isHead) : null
@@ -296,16 +295,12 @@ function isHeadMethod (spec, api) {
   return methods.length === 1 && methods[0] === 'HEAD'
 }
 
-function readSpec (paths, file) {
+function readSpec (specFolder, file) {
   try {
-    return require(join(paths[0], file))
+    return require(join(specFolder, file))
-  } catch (err) {}
+  } catch (err) {
-
+    throw new Error(`Cannot read spec file ${file}`)
-  try {
+  }
-    return require(join(paths[1], file))
-  } catch (err) {}
-
-  throw new Error(`Cannot read spec file ${file}`)
 }
 
 module.exports = genFactory

scripts/utils/generateRequestTypes.js

@@ -19,7 +19,6 @@
 
 'use strict'
 
-const semver = require('semver')
 const deprecatedParameters = require('./patch.json')
 const { ndjsonApi } = require('./generateApis')
 
@@ -32,7 +31,7 @@ const ndjsonApiKey = ndjsonApi
   .map(toPascalCase)
 
 function generate (version, api) {
-  const release = semver.valid(version) ? semver.major(version) : version
+  const release = version.charAt(0)
   let types = `/*
  * Licensed to Elasticsearch B.V. under one or more contributor
  * license agreements. See the NOTICE file distributed with

scripts/utils/index.js

@@ -23,10 +23,12 @@ const generate = require('./generateApis')
 const cloneAndCheckout = require('./clone-es')
 const genFactory = require('./generateMain')
 const generateDocs = require('./generateDocs')
+const generateRequestTypes = require('./generateRequestTypes')
 
 module.exports = {
   generate,
   cloneAndCheckout,
   genFactory,
-  generateDocs
+  generateDocs,
+  generateRequestTypes
 }

scripts/utils/patch.json

@@ -7,7 +7,7 @@
     "_source_includes": "_source_include",
     "_source_excludes": "_source_exclude"
   },
-  "master": {
+  "8": {
     "_source_includes": "_source_include",
     "_source_excludes": "_source_exclude"
   }

test/types/api-response-body.test-d.ts

@@ -20,12 +20,57 @@
 import { expectType, expectError } from 'tsd'
 import { Readable as ReadableStream } from 'stream';
 import { TransportRequestCallback, Context } from '../../lib/Transport'
-import { Client, ApiError, estypes } from '../../'
+import { Client, ApiError } from '../../'
 
 const client = new Client({
   node: 'http://localhost:9200'
 })
 
+interface SearchBody {
+  query: {
+    match: { foo: string }
+  }
+}
+
+interface ShardsResponse {
+  total: number;
+  successful: number;
+  failed: number;
+  skipped: number;
+}
+
+interface Explanation {
+  value: number;
+  description: string;
+  details: Explanation[];
+}
+
+interface SearchResponse<T> {
+  took: number;
+  timed_out: boolean;
+  _scroll_id?: string;
+  _shards: ShardsResponse;
+  hits: {
+    total: number;
+    max_score: number;
+    hits: Array<{
+      _index: string;
+      _type: string;
+      _id: string;
+      _score: number;
+      _source: T;
+      _version?: number;
+      _explanation?: Explanation;
+      fields?: any;
+      highlight?: any;
+      inner_hits?: any;
+      matched_queries?: string[];
+      sort?: string[];
+    }>;
+  };
+  aggregations?: any;
+}
+
 interface Source {
   foo: string
 }
@@ -49,13 +94,13 @@ expectError(
     }
   })
 
-  expectType<estypes.SearchResponse<unknown>>(response.body)
+  expectType<Record<string, any>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
-// Define only the source (promise style)
+// Define only the response body (promise style)
 {
-  const response = await client.search<Source>({
+  const response = await client.search<SearchResponse<Source>>({
     index: 'test',
     body: {
       query: {
@@ -64,13 +109,28 @@ expectError(
     }
   })
 
-  expectType<estypes.SearchResponse<Source>>(response.body)
+  expectType<SearchResponse<Source>>(response.body)
+  expectType<Context>(response.meta.context)
+}
+
+// Define response body and request body (promise style)
+{
+  const response = await client.search<SearchResponse<Source>, SearchBody>({
+    index: 'test',
+    body: {
+      query: {
+        match: { foo: 'bar' }
+      }
+    }
+  })
+
+  expectType<SearchResponse<Source>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
 // Define response body, request body and the context (promise style)
 {
-  const response = await client.search<Source, Context>({
+  const response = await client.search<SearchResponse<Source>, SearchBody, Context>({
     index: 'test',
     body: {
       query: {
@@ -79,7 +139,40 @@ expectError(
     }
   })
 
-  expectType<estypes.SearchResponse<Source>>(response.body)
+  expectType<SearchResponse<Source>>(response.body)
+  expectType<Context>(response.meta.context)
+}
+
+// Send request body as string (promise style)
+{
+  const response = await client.search({
+    index: 'test',
+    body: 'hello world'
+  })
+
+  expectType<Record<string, any>>(response.body)
+  expectType<Context>(response.meta.context)
+}
+
+// Send request body as buffer (promise style)
+{
+  const response = await client.search({
+    index: 'test',
+    body: Buffer.from('hello world')
+  })
+
+  expectType<Record<string, any>>(response.body)
+  expectType<Context>(response.meta.context)
+}
+
+// Send request body as readable stream (promise style)
+{
+  const response = await client.search({
+    index: 'test',
+    body: new ReadableStream()
+  })
+
+  expectType<Record<string, any>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
@@ -94,7 +187,7 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<estypes.SearchResponse<unknown>>(response.body)
+    expectType<Record<string, any>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
@@ -102,7 +195,7 @@ expectError(
 
 // Define only the response body (callback style)
 {
-  const result = client.search<Source>({
+  const result = client.search<SearchResponse<Source>>({
     index: 'test',
     body: {
       query: {
@@ -111,7 +204,24 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<estypes.SearchResponse<Source>>(response.body)
+    expectType<SearchResponse<Source>>(response.body)
+    expectType<Context>(response.meta.context)
+  })
+  expectType<TransportRequestCallback>(result)
+}
+
+// Define response body and request body (callback style)
+{
+  const result = client.search<SearchResponse<Source>, SearchBody>({
+    index: 'test',
+    body: {
+      query: {
+        match: { foo: 'bar' }
+      }
+    }
+  }, (err, response) => {
+    expectType<ApiError>(err)
+    expectType<SearchResponse<Source>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
@@ -119,7 +229,7 @@ expectError(
 
 // Define response body, request body and the context (callback style)
 {
-  const result = client.search<Source, Context>({
+  const result = client.search<SearchResponse<Source>, SearchBody, Context>({
     index: 'test',
     body: {
       query: {
@@ -128,7 +238,46 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<estypes.SearchResponse<Source>>(response.body)
+    expectType<SearchResponse<Source>>(response.body)
+    expectType<Context>(response.meta.context)
+  })
+  expectType<TransportRequestCallback>(result)
+}
+
+// Send request body as string (callback style)
+{
+  const result = client.search({
+    index: 'test',
+    body: 'hello world'
+  }, (err, response) => {
+    expectType<ApiError>(err)
+    expectType<Record<string, any>>(response.body)
+    expectType<Context>(response.meta.context)
+  })
+  expectType<TransportRequestCallback>(result)
+}
+
+// Send request body as buffer (callback style)
+{
+  const result = client.search({
+    index: 'test',
+    body: Buffer.from('hello world')
+  }, (err, response) => {
+    expectType<ApiError>(err)
+    expectType<Record<string, any>>(response.body)
+    expectType<Context>(response.meta.context)
+  })
+  expectType<TransportRequestCallback>(result)
+}
+
+// Send request body as readable stream (callback style)
+{
+  const result = client.search({
+    index: 'test',
+    body: new ReadableStream()
+  }, (err, response) => {
+    expectType<ApiError>(err)
+    expectType<Record<string, any>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)

test/types/api-response.test-d.ts

@@ -19,7 +19,7 @@
 
 import { expectType } from 'tsd'
 import { TransportRequestCallback, Context } from '../../lib/Transport'
-import { Client, ApiError, estypes } from '../../'
+import { Client, ApiError } from '../../'
 
 const client = new Client({
   node: 'http://localhost:9200'
@@ -29,15 +29,23 @@ const client = new Client({
 {
   const response = await client.cat.count({ index: 'test' })
 
-  expectType<estypes.CatCountResponse>(response.body)
+  expectType<Record<string, any>>(response.body)
   expectType<Context>(response.meta.context)
 }
 
-// Define the context (promise style)
+// Define only the response body (promise style)
 {
   const response = await client.cat.count<string>({ index: 'test' })
 
-  expectType<estypes.CatCountResponse>(response.body)
+  expectType<string>(response.body)
+  expectType<Context>(response.meta.context)
+}
+
+// Define response body and the context (promise style)
+{
+  const response = await client.cat.count<string, string>({ index: 'test' })
+
+  expectType<string>(response.body)
   expectType<string>(response.meta.context)
 }
 
@@ -45,18 +53,28 @@ const client = new Client({
 {
   const result = client.cat.count({ index: 'test' }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<estypes.CatCountResponse>(response.body)
+    expectType<Record<string, any>>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
 }
 
-// Define the context (callback style)
+// Define only the response body (callback style)
 {
   const result = client.cat.count<string>({ index: 'test' }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<estypes.CatCountResponse>(response.body)
+    expectType<string>(response.body)
-    expectType<string>(response.meta.context)
+    expectType<Context>(response.meta.context)
+  })
+  expectType<TransportRequestCallback>(result)
+}
+
+// Define response body and the context (callback style)
+{
+  const result = client.cat.count<string, Context>({ index: 'test' }, (err, response) => {
+    expectType<ApiError>(err)
+    expectType<string>(response.body)
+    expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
 }

test/types/client.test-d.ts

@@ -18,8 +18,8 @@
  */
 
 import { expectType } from 'tsd'
-import { Client, ApiError, ApiResponse, RequestEvent, ResurrectEvent, estypes } from '../../'
+import { Client, ApiError, ApiResponse, RequestEvent, ResurrectEvent } from '../../'
-import { TransportRequestCallback, TransportRequestPromise, Context } from '../../lib/Transport'
+import { TransportRequestCallback, TransportRequestPromise } from '../../lib/Transport'
 
 const client = new Client({
   node: 'http://localhost:9200'
@@ -51,7 +51,7 @@ client.on('resurrect', (err, meta) => {
 {
   const result = client.info((err, result) => {
     expectType<ApiError>(err)
-    expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result)
+    expectType<ApiResponse>(result)
   })
   expectType<TransportRequestCallback>(result)
   expectType<void>(result.abort())
@@ -60,7 +60,7 @@ client.on('resurrect', (err, meta) => {
 {
   const result = client.info({ pretty: true }, (err, result) => {
     expectType<ApiError>(err)
-    expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result)
+    expectType<ApiResponse>(result)
   })
   expectType<TransportRequestCallback>(result)
   expectType<void>(result.abort())
@@ -69,7 +69,7 @@ client.on('resurrect', (err, meta) => {
 {
   const result = client.info({ pretty: true }, { ignore: [404] }, (err, result) => {
     expectType<ApiError>(err)
-    expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result)
+    expectType<ApiResponse>(result)
   })
   expectType<TransportRequestCallback>(result)
   expectType<void>(result.abort())
@@ -78,27 +78,27 @@ client.on('resurrect', (err, meta) => {
 // Promise style
 {
   const promise = client.info()
-  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  expectType<TransportRequestPromise<ApiResponse>>(promise)
   promise
-    .then(result => expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result))
+    .then(result => expectType<ApiResponse>(result))
     .catch((err: ApiError) => expectType<ApiError>(err))
   expectType<void>(promise.abort())
 }
 
 {
   const promise = client.info({ pretty: true })
-  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  expectType<TransportRequestPromise<ApiResponse>>(promise)
   promise
-    .then(result => expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result))
+    .then(result => expectType<ApiResponse>(result))
     .catch((err: ApiError) => expectType<ApiError>(err))
   expectType<void>(promise.abort())
 }
 
 {
   const promise = client.info({ pretty: true }, { ignore: [404] })
-  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  expectType<TransportRequestPromise<ApiResponse>>(promise)
   promise
-    .then(result => expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result))
+    .then(result => expectType<ApiResponse>(result))
     .catch((err: ApiError) => expectType<ApiError>(err))
   expectType<void>(promise.abort())
 }
@@ -106,10 +106,10 @@ client.on('resurrect', (err, meta) => {
 // Promise style with async await
 {
   const promise = client.info()
-  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  expectType<TransportRequestPromise<ApiResponse>>(promise)
   expectType<void>(promise.abort())
   try {
-    expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(await promise)
+    expectType<ApiResponse>(await promise)
   } catch (err) {
     expectType<any>(err)
   }
@@ -117,10 +117,10 @@ client.on('resurrect', (err, meta) => {
 
 {
   const promise = client.info({ pretty: true })
-  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  expectType<TransportRequestPromise<ApiResponse>>(promise)
   expectType<void>(promise.abort())
   try {
-    expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(await promise)
+    expectType<ApiResponse>(await promise)
   } catch (err) {
     expectType<any>(err)
   }
@@ -128,10 +128,10 @@ client.on('resurrect', (err, meta) => {
 
 {
   const promise = client.info({ pretty: true }, { ignore: [404] })
-  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  expectType<TransportRequestPromise<ApiResponse>>(promise)
   expectType<void>(promise.abort())
   try {
-    expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(await promise)
+    expectType<ApiResponse>(await promise)
   } catch (err) {
     expectType<any>(err)
   }

test/types/errors.test-d.ts

@@ -101,4 +101,4 @@ const response = {
   expectType<string>(err.name)
   expectType<string>(err.message)
   expectType<ApiResponse>(err.meta)
-}
+}

test/types/kibana.test-d.ts

@@ -22,6 +22,7 @@ import { Client, RequestEvent, ResurrectEvent, ApiError, ApiResponse, estypes }
 import { KibanaClient } from '../../api/kibana'
 import { TransportRequestPromise, Context } from '../../lib/Transport'
 
+// @ts-expect-error
 const client: KibanaClient = new Client({
   node: 'http://localhost:9200'
 })
@@ -112,4 +113,4 @@ expectError(client.close(() => {}))
 // the child api should return a KibanaClient instance
 const child = client.child()
 expectType<KibanaClient>(child)
-expectNotType<Client>(child)
+expectNotType<Client>(child)

test/types/new-types.test-d.ts

@@ -0,0 +1,108 @@
+/*
+ * 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.
+ */
+
+import { expectType, expectNotType, expectError } from 'tsd'
+import { Client, RequestEvent, ResurrectEvent, ApiError, ApiResponse, estypes } from '../../'
+import { NewClientTypes } from '../../api/new'
+import { TransportRequestPromise, Context } from '../../lib/Transport'
+
+// @ts-expect-error
+const client: NewClientTypes = new Client({
+  node: 'http://localhost:9200'
+})
+
+client.on('request', (err, meta) => {
+  expectType<ApiError>(err)
+  expectType<RequestEvent>(meta)
+})
+
+client.on('response', (err, meta) => {
+  expectType<ApiError>(err)
+  expectType<RequestEvent>(meta)
+})
+
+client.on('sniff', (err, meta) => {
+  expectType<ApiError>(err)
+  expectType<RequestEvent>(meta)
+})
+
+client.on('resurrect', (err, meta) => {
+  expectType<null>(err)
+  expectType<ResurrectEvent>(meta)
+})
+
+// No generics
+{
+  const response = await client.cat.count({ index: 'test' })
+
+  expectType<estypes.CatCountResponse>(response.body)
+  expectType<Context>(response.meta.context)
+}
+
+// Define only the context
+{
+  const response = await client.cat.count<string>({ index: 'test' })
+
+  expectType<estypes.CatCountResponse>(response.body)
+  expectType<string>(response.meta.context)
+}
+
+// Check API returned type and optional parameters
+{
+  const promise = client.info()
+  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  promise
+    .then(result => expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result))
+    .catch((err: ApiError) => expectType<ApiError>(err))
+  expectType<void>(promise.abort())
+}
+
+{
+  const promise = client.info({ pretty: true })
+  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  promise
+    .then(result => expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result))
+    .catch((err: ApiError) => expectType<ApiError>(err))
+  expectType<void>(promise.abort())
+}
+
+{
+  const promise = client.info({ pretty: true }, { ignore: [404] })
+  expectType<TransportRequestPromise<ApiResponse<estypes.RootNodeInfoResponse, Context>>>(promise)
+  promise
+    .then(result => expectType<ApiResponse<estypes.RootNodeInfoResponse, Context>>(result))
+    .catch((err: ApiError) => expectType<ApiError>(err))
+  expectType<void>(promise.abort())
+}
+
+// body that does not respect the RequestBody constraint
+expectError(
+  client.search({
+    index: 'hello',
+    body: 42
+  }).then(console.log)
+)
+
+// @ts-expect-error
+client.async_search.get()
+
+// the child api should return a KibanaClient instance
+const child = client.child()
+expectType<NewClientTypes>(child)
+expectNotType<Client>(child)