diff --git a/api/requestParams.d.ts b/api/RequestTypes.d.ts
similarity index 57%
rename from api/requestParams.d.ts
rename to api/RequestTypes.d.ts
index faee308e9..bf52b65f2 100644
--- a/api/requestParams.d.ts
+++ b/api/RequestTypes.d.ts
@@ -4,7 +4,7 @@
 
 import { RequestBody, RequestNDBody } from '../lib/Transport'
 
-export interface Generic {
+interface GenericRequest {
   method?: string;
   filter_path?: string | string[];
   pretty?: boolean;
@@ -13,7 +13,7 @@ export interface Generic {
   source?: string;
 }
 
-export interface Bulk<T = RequestNDBody> extends Generic {
+interface BulkRequest<T = RequestNDBody> extends GenericRequest {
   index?: string;
   type?: string;
   _source_exclude?: string | string[];
@@ -30,7 +30,7 @@ export interface Bulk<T = RequestNDBody> extends Generic {
   body: T;
 }
 
-export interface CatAliases extends Generic {
+interface CatAliasesRequest extends GenericRequest {
   name?: string | string[];
   format?: string;
   local?: boolean;
@@ -41,7 +41,7 @@ export interface CatAliases extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface CatAllocation extends Generic {
+interface CatAllocationRequest extends GenericRequest {
   node_id?: string | string[];
   format?: string;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -53,7 +53,7 @@ export interface CatAllocation extends Generic {
   v?: boolean;
 }
 
-export interface CatCount extends Generic {
+interface CatCountRequest extends GenericRequest {
   index?: string | string[];
   format?: string;
   h?: string | string[];
@@ -62,7 +62,7 @@ export interface CatCount extends Generic {
   v?: boolean;
 }
 
-export interface CatFielddata extends Generic {
+interface CatFielddataRequest extends GenericRequest {
   fields?: string | string[];
   format?: string;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -72,7 +72,7 @@ export interface CatFielddata extends Generic {
   v?: boolean;
 }
 
-export interface CatHealth extends Generic {
+interface CatHealthRequest extends GenericRequest {
   format?: string;
   h?: string | string[];
   help?: boolean;
@@ -82,12 +82,12 @@ export interface CatHealth extends Generic {
   v?: boolean;
 }
 
-export interface CatHelp extends Generic {
+interface CatHelpRequest extends GenericRequest {
   help?: boolean;
   s?: string | string[];
 }
 
-export interface CatIndices extends Generic {
+interface CatIndicesRequest extends GenericRequest {
   index?: string | string[];
   format?: string;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -104,7 +104,7 @@ export interface CatIndices extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface CatMaster extends Generic {
+interface CatMasterRequest extends GenericRequest {
   format?: string;
   local?: boolean;
   master_timeout?: string;
@@ -114,7 +114,7 @@ export interface CatMaster extends Generic {
   v?: boolean;
 }
 
-export interface CatNodeattrs extends Generic {
+interface CatNodeattrsRequest extends GenericRequest {
   format?: string;
   local?: boolean;
   master_timeout?: string;
@@ -124,7 +124,7 @@ export interface CatNodeattrs extends Generic {
   v?: boolean;
 }
 
-export interface CatNodes extends Generic {
+interface CatNodesRequest extends GenericRequest {
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
   format?: string;
   full_id?: boolean;
@@ -136,7 +136,7 @@ export interface CatNodes extends Generic {
   v?: boolean;
 }
 
-export interface CatPendingTasks extends Generic {
+interface CatPendingTasksRequest extends GenericRequest {
   format?: string;
   local?: boolean;
   master_timeout?: string;
@@ -147,7 +147,7 @@ export interface CatPendingTasks extends Generic {
   v?: boolean;
 }
 
-export interface CatPlugins extends Generic {
+interface CatPluginsRequest extends GenericRequest {
   format?: string;
   local?: boolean;
   master_timeout?: string;
@@ -157,7 +157,7 @@ export interface CatPlugins extends Generic {
   v?: boolean;
 }
 
-export interface CatRecovery extends Generic {
+interface CatRecoveryRequest extends GenericRequest {
   index?: string | string[];
   format?: string;
   active_only?: boolean;
@@ -170,7 +170,7 @@ export interface CatRecovery extends Generic {
   v?: boolean;
 }
 
-export interface CatRepositories extends Generic {
+interface CatRepositoriesRequest extends GenericRequest {
   format?: string;
   local?: boolean;
   master_timeout?: string;
@@ -180,7 +180,7 @@ export interface CatRepositories extends Generic {
   v?: boolean;
 }
 
-export interface CatSegments extends Generic {
+interface CatSegmentsRequest extends GenericRequest {
   index?: string | string[];
   format?: string;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -190,7 +190,7 @@ export interface CatSegments extends Generic {
   v?: boolean;
 }
 
-export interface CatShards extends Generic {
+interface CatShardsRequest extends GenericRequest {
   index?: string | string[];
   format?: string;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -203,7 +203,7 @@ export interface CatShards extends Generic {
   v?: boolean;
 }
 
-export interface CatSnapshots extends Generic {
+interface CatSnapshotsRequest extends GenericRequest {
   repository?: string | string[];
   format?: string;
   ignore_unavailable?: boolean;
@@ -215,7 +215,7 @@ export interface CatSnapshots extends Generic {
   v?: boolean;
 }
 
-export interface CatTasks extends Generic {
+interface CatTasksRequest extends GenericRequest {
   format?: string;
   node_id?: string | string[];
   actions?: string | string[];
@@ -228,7 +228,7 @@ export interface CatTasks extends Generic {
   v?: boolean;
 }
 
-export interface CatTemplates extends Generic {
+interface CatTemplatesRequest extends GenericRequest {
   name?: string;
   format?: string;
   local?: boolean;
@@ -239,7 +239,7 @@ export interface CatTemplates extends Generic {
   v?: boolean;
 }
 
-export interface CatThreadPool extends Generic {
+interface CatThreadPoolRequest extends GenericRequest {
   thread_pool_patterns?: string | string[];
   format?: string;
   time?: 'd' | 'h' | 'm' | 's' | 'ms' | 'micros' | 'nanos';
@@ -251,47 +251,47 @@ export interface CatThreadPool extends Generic {
   v?: boolean;
 }
 
-export interface ClearScroll<T = RequestBody> extends Generic {
+interface ClearScrollRequest<T = RequestBody> extends GenericRequest {
   scroll_id?: string | string[];
   body?: T;
 }
 
-export interface ClusterAllocationExplain<T = RequestBody> extends Generic {
+interface ClusterAllocationExplainRequest<T = RequestBody> extends GenericRequest {
   include_yes_decisions?: boolean;
   include_disk_info?: boolean;
   body?: T;
 }
 
-export interface ClusterDeleteComponentTemplate extends Generic {
+interface ClusterDeleteComponentTemplateRequest extends GenericRequest {
   name: string;
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface ClusterDeleteVotingConfigExclusions extends Generic {
+interface ClusterDeleteVotingConfigExclusionsRequest extends GenericRequest {
   wait_for_removal?: boolean;
 }
 
-export interface ClusterExistsComponentTemplate extends Generic {
+interface ClusterExistsComponentTemplateRequest extends GenericRequest {
   name: string;
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface ClusterGetComponentTemplate extends Generic {
+interface ClusterGetComponentTemplateRequest extends GenericRequest {
   name?: string | string[];
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface ClusterGetSettings extends Generic {
+interface ClusterGetSettingsRequest extends GenericRequest {
   flat_settings?: boolean;
   master_timeout?: string;
   timeout?: string;
   include_defaults?: boolean;
 }
 
-export interface ClusterHealth extends Generic {
+interface ClusterHealthRequest extends GenericRequest {
   index?: string | string[];
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
   level?: 'cluster' | 'indices' | 'shards';
@@ -306,18 +306,18 @@ export interface ClusterHealth extends Generic {
   wait_for_status?: 'green' | 'yellow' | 'red';
 }
 
-export interface ClusterPendingTasks extends Generic {
+interface ClusterPendingTasksRequest extends GenericRequest {
   local?: boolean;
   master_timeout?: string;
 }
 
-export interface ClusterPostVotingConfigExclusions extends Generic {
+interface ClusterPostVotingConfigExclusionsRequest extends GenericRequest {
   node_ids?: string;
   node_names?: string;
   timeout?: string;
 }
 
-export interface ClusterPutComponentTemplate<T = RequestBody> extends Generic {
+interface ClusterPutComponentTemplateRequest<T = RequestBody> extends GenericRequest {
   name: string;
   create?: boolean;
   timeout?: string;
@@ -325,17 +325,17 @@ export interface ClusterPutComponentTemplate<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface ClusterPutSettings<T = RequestBody> extends Generic {
+interface ClusterPutSettingsRequest<T = RequestBody> extends GenericRequest {
   flat_settings?: boolean;
   master_timeout?: string;
   timeout?: string;
   body: T;
 }
 
-export interface ClusterRemoteInfo extends Generic {
+interface ClusterRemoteInfoRequest extends GenericRequest {
 }
 
-export interface ClusterReroute<T = RequestBody> extends Generic {
+interface ClusterRerouteRequest<T = RequestBody> extends GenericRequest {
   dry_run?: boolean;
   explain?: boolean;
   retry_failed?: boolean;
@@ -345,7 +345,7 @@ export interface ClusterReroute<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface ClusterState extends Generic {
+interface ClusterStateRequest extends GenericRequest {
   index?: string | string[];
   metric?: string | string[];
   local?: boolean;
@@ -358,13 +358,13 @@ export interface ClusterState extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface ClusterStats extends Generic {
+interface ClusterStatsRequest extends GenericRequest {
   node_id?: string | string[];
   flat_settings?: boolean;
   timeout?: string;
 }
 
-export interface Count<T = RequestBody> extends Generic {
+interface CountRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   ignore_throttled?: boolean;
@@ -383,7 +383,7 @@ export interface Count<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface Create<T = RequestBody> extends Generic {
+interface CreateRequest<T = RequestBody> extends GenericRequest {
   id: string;
   index: string;
   type?: string;
@@ -397,24 +397,24 @@ export interface Create<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface DanglingIndicesDeleteDanglingIndex extends Generic {
+interface DanglingIndicesDeleteDanglingIndexRequest extends GenericRequest {
   index_uuid: string;
   accept_data_loss?: boolean;
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface DanglingIndicesImportDanglingIndex extends Generic {
+interface DanglingIndicesImportDanglingIndexRequest extends GenericRequest {
   index_uuid: string;
   accept_data_loss?: boolean;
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface DanglingIndicesListDanglingIndices extends Generic {
+interface DanglingIndicesListDanglingIndicesRequest extends GenericRequest {
 }
 
-export interface Delete extends Generic {
+interface DeleteRequest extends GenericRequest {
   id: string;
   index: string;
   type?: string;
@@ -428,7 +428,7 @@ export interface Delete extends Generic {
   version_type?: 'internal' | 'external' | 'external_gte';
 }
 
-export interface DeleteByQuery<T = RequestBody> extends Generic {
+interface DeleteByQueryRequest<T = RequestBody> extends GenericRequest {
   index: string | string[];
   _source_exclude?: string | string[];
   _source_include?: string | string[];
@@ -467,18 +467,18 @@ export interface DeleteByQuery<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface DeleteByQueryRethrottle extends Generic {
+interface DeleteByQueryRethrottleRequest extends GenericRequest {
   task_id: string;
   requests_per_second: number;
 }
 
-export interface DeleteScript extends Generic {
+interface DeleteScriptRequest extends GenericRequest {
   id: string;
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface Exists extends Generic {
+interface ExistsRequest extends GenericRequest {
   id: string;
   index: string;
   _source_exclude?: string | string[];
@@ -495,7 +495,7 @@ export interface Exists extends Generic {
   version_type?: 'internal' | 'external' | 'external_gte';
 }
 
-export interface ExistsSource extends Generic {
+interface ExistsSourceRequest extends GenericRequest {
   id: string;
   index: string;
   type?: string;
@@ -512,7 +512,7 @@ export interface ExistsSource extends Generic {
   version_type?: 'internal' | 'external' | 'external_gte';
 }
 
-export interface Explain<T = RequestBody> extends Generic {
+interface ExplainRequest<T = RequestBody> extends GenericRequest {
   id: string;
   index: string;
   _source_exclude?: string | string[];
@@ -532,7 +532,7 @@ export interface Explain<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface FieldCaps<T = RequestBody> extends Generic {
+interface FieldCapsRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   fields?: string | string[];
   ignore_unavailable?: boolean;
@@ -542,7 +542,7 @@ export interface FieldCaps<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface Get extends Generic {
+interface GetRequest extends GenericRequest {
   id: string;
   index: string;
   _source_exclude?: string | string[];
@@ -559,18 +559,18 @@ export interface Get extends Generic {
   version_type?: 'internal' | 'external' | 'external_gte';
 }
 
-export interface GetScript extends Generic {
+interface GetScriptRequest extends GenericRequest {
   id: string;
   master_timeout?: string;
 }
 
-export interface GetScriptContext extends Generic {
+interface GetScriptContextRequest extends GenericRequest {
 }
 
-export interface GetScriptLanguages extends Generic {
+interface GetScriptLanguagesRequest extends GenericRequest {
 }
 
-export interface GetSource extends Generic {
+interface GetSourceRequest extends GenericRequest {
   id: string;
   index: string;
   _source_exclude?: string | string[];
@@ -586,7 +586,7 @@ export interface GetSource extends Generic {
   version_type?: 'internal' | 'external' | 'external_gte';
 }
 
-export interface Index<T = RequestBody> extends Generic {
+interface IndexRequest<T = RequestBody> extends GenericRequest {
   id?: string;
   index: string;
   wait_for_active_shards?: string;
@@ -603,7 +603,7 @@ export interface Index<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface IndicesAddBlock extends Generic {
+interface IndicesAddBlockRequest extends GenericRequest {
   index: string | string[];
   block: string;
   timeout?: string;
@@ -613,12 +613,12 @@ export interface IndicesAddBlock extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesAnalyze<T = RequestBody> extends Generic {
+interface IndicesAnalyzeRequest<T = RequestBody> extends GenericRequest {
   index?: string;
   body?: T;
 }
 
-export interface IndicesClearCache extends Generic {
+interface IndicesClearCacheRequest extends GenericRequest {
   index?: string | string[];
   fielddata?: boolean;
   fields?: string | string[];
@@ -629,7 +629,7 @@ export interface IndicesClearCache extends Generic {
   request?: boolean;
 }
 
-export interface IndicesClone<T = RequestBody> extends Generic {
+interface IndicesCloneRequest<T = RequestBody> extends GenericRequest {
   index: string;
   target: string;
   timeout?: string;
@@ -638,7 +638,7 @@ export interface IndicesClone<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesClose extends Generic {
+interface IndicesCloseRequest extends GenericRequest {
   index: string | string[];
   timeout?: string;
   master_timeout?: string;
@@ -648,7 +648,7 @@ export interface IndicesClose extends Generic {
   wait_for_active_shards?: string;
 }
 
-export interface IndicesCreate<T = RequestBody> extends Generic {
+interface IndicesCreateRequest<T = RequestBody> extends GenericRequest {
   index: string;
   wait_for_active_shards?: string;
   timeout?: string;
@@ -656,7 +656,7 @@ export interface IndicesCreate<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesDelete extends Generic {
+interface IndicesDeleteRequest extends GenericRequest {
   index: string | string[];
   timeout?: string;
   master_timeout?: string;
@@ -665,26 +665,26 @@ export interface IndicesDelete extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesDeleteAlias extends Generic {
+interface IndicesDeleteAliasRequest extends GenericRequest {
   index: string | string[];
   name: string | string[];
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface IndicesDeleteIndexTemplate extends Generic {
+interface IndicesDeleteIndexTemplateRequest extends GenericRequest {
   name: string;
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface IndicesDeleteTemplate extends Generic {
+interface IndicesDeleteTemplateRequest extends GenericRequest {
   name: string;
   timeout?: string;
   master_timeout?: string;
 }
 
-export interface IndicesExists extends Generic {
+interface IndicesExistsRequest extends GenericRequest {
   index: string | string[];
   local?: boolean;
   ignore_unavailable?: boolean;
@@ -694,7 +694,7 @@ export interface IndicesExists extends Generic {
   include_defaults?: boolean;
 }
 
-export interface IndicesExistsAlias extends Generic {
+interface IndicesExistsAliasRequest extends GenericRequest {
   name: string | string[];
   index?: string | string[];
   ignore_unavailable?: boolean;
@@ -703,21 +703,21 @@ export interface IndicesExistsAlias extends Generic {
   local?: boolean;
 }
 
-export interface IndicesExistsIndexTemplate extends Generic {
+interface IndicesExistsIndexTemplateRequest extends GenericRequest {
   name: string;
   flat_settings?: boolean;
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface IndicesExistsTemplate extends Generic {
+interface IndicesExistsTemplateRequest extends GenericRequest {
   name: string | string[];
   flat_settings?: boolean;
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface IndicesExistsType extends Generic {
+interface IndicesExistsTypeRequest extends GenericRequest {
   index: string | string[];
   type: string | string[];
   ignore_unavailable?: boolean;
@@ -726,7 +726,7 @@ export interface IndicesExistsType extends Generic {
   local?: boolean;
 }
 
-export interface IndicesFlush extends Generic {
+interface IndicesFlushRequest extends GenericRequest {
   index?: string | string[];
   force?: boolean;
   wait_if_ongoing?: boolean;
@@ -735,7 +735,7 @@ export interface IndicesFlush extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesForcemerge extends Generic {
+interface IndicesForcemergeRequest extends GenericRequest {
   index?: string | string[];
   flush?: boolean;
   ignore_unavailable?: boolean;
@@ -745,7 +745,7 @@ export interface IndicesForcemerge extends Generic {
   only_expunge_deletes?: boolean;
 }
 
-export interface IndicesGet extends Generic {
+interface IndicesGetRequest extends GenericRequest {
   index: string | string[];
   local?: boolean;
   ignore_unavailable?: boolean;
@@ -756,7 +756,7 @@ export interface IndicesGet extends Generic {
   master_timeout?: string;
 }
 
-export interface IndicesGetAlias extends Generic {
+interface IndicesGetAliasRequest extends GenericRequest {
   name?: string | string[];
   index?: string | string[];
   ignore_unavailable?: boolean;
@@ -765,7 +765,7 @@ export interface IndicesGetAlias extends Generic {
   local?: boolean;
 }
 
-export interface IndicesGetFieldMapping extends Generic {
+interface IndicesGetFieldMappingRequest extends GenericRequest {
   fields: string | string[];
   index?: string | string[];
   include_defaults?: boolean;
@@ -775,14 +775,14 @@ export interface IndicesGetFieldMapping extends Generic {
   local?: boolean;
 }
 
-export interface IndicesGetIndexTemplate extends Generic {
+interface IndicesGetIndexTemplateRequest extends GenericRequest {
   name?: string | string[];
   flat_settings?: boolean;
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface IndicesGetMapping extends Generic {
+interface IndicesGetMappingRequest extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
@@ -791,7 +791,7 @@ export interface IndicesGetMapping extends Generic {
   local?: boolean;
 }
 
-export interface IndicesGetSettings extends Generic {
+interface IndicesGetSettingsRequest extends GenericRequest {
   index?: string | string[];
   name?: string | string[];
   master_timeout?: string;
@@ -803,21 +803,21 @@ export interface IndicesGetSettings extends Generic {
   include_defaults?: boolean;
 }
 
-export interface IndicesGetTemplate extends Generic {
+interface IndicesGetTemplateRequest extends GenericRequest {
   name?: string | string[];
   flat_settings?: boolean;
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface IndicesGetUpgrade extends Generic {
+interface IndicesGetUpgradeRequest extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesOpen extends Generic {
+interface IndicesOpenRequest extends GenericRequest {
   index: string | string[];
   timeout?: string;
   master_timeout?: string;
@@ -827,7 +827,7 @@ export interface IndicesOpen extends Generic {
   wait_for_active_shards?: string;
 }
 
-export interface IndicesPutAlias<T = RequestBody> extends Generic {
+interface IndicesPutAliasRequest<T = RequestBody> extends GenericRequest {
   index: string | string[];
   name: string;
   timeout?: string;
@@ -835,7 +835,7 @@ export interface IndicesPutAlias<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesPutIndexTemplate<T = RequestBody> extends Generic {
+interface IndicesPutIndexTemplateRequest<T = RequestBody> extends GenericRequest {
   name: string;
   create?: boolean;
   cause?: string;
@@ -843,7 +843,7 @@ export interface IndicesPutIndexTemplate<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface IndicesPutMapping<T = RequestBody> extends Generic {
+interface IndicesPutMappingRequest<T = RequestBody> extends GenericRequest {
   index: string | string[];
   timeout?: string;
   master_timeout?: string;
@@ -854,7 +854,7 @@ export interface IndicesPutMapping<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface IndicesPutSettings<T = RequestBody> extends Generic {
+interface IndicesPutSettingsRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   master_timeout?: string;
   timeout?: string;
@@ -866,7 +866,7 @@ export interface IndicesPutSettings<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface IndicesPutTemplate<T = RequestBody> extends Generic {
+interface IndicesPutTemplateRequest<T = RequestBody> extends GenericRequest {
   name: string;
   order?: number;
   create?: boolean;
@@ -874,25 +874,25 @@ export interface IndicesPutTemplate<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface IndicesRecovery extends Generic {
+interface IndicesRecoveryRequest extends GenericRequest {
   index?: string | string[];
   detailed?: boolean;
   active_only?: boolean;
 }
 
-export interface IndicesRefresh extends Generic {
+interface IndicesRefreshRequest extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesResolveIndex extends Generic {
+interface IndicesResolveIndexRequest extends GenericRequest {
   name: string | string[];
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesRollover<T = RequestBody> extends Generic {
+interface IndicesRolloverRequest<T = RequestBody> extends GenericRequest {
   alias: string;
   new_index?: string;
   timeout?: string;
@@ -902,7 +902,7 @@ export interface IndicesRollover<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesSegments extends Generic {
+interface IndicesSegmentsRequest extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
@@ -910,7 +910,7 @@ export interface IndicesSegments extends Generic {
   verbose?: boolean;
 }
 
-export interface IndicesShardStores extends Generic {
+interface IndicesShardStoresRequest extends GenericRequest {
   index?: string | string[];
   status?: string | string[];
   ignore_unavailable?: boolean;
@@ -918,7 +918,7 @@ export interface IndicesShardStores extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesShrink<T = RequestBody> extends Generic {
+interface IndicesShrinkRequest<T = RequestBody> extends GenericRequest {
   index: string;
   target: string;
   timeout?: string;
@@ -927,7 +927,7 @@ export interface IndicesShrink<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesSimulateIndexTemplate<T = RequestBody> extends Generic {
+interface IndicesSimulateIndexTemplateRequest<T = RequestBody> extends GenericRequest {
   name: string;
   create?: boolean;
   cause?: string;
@@ -935,7 +935,7 @@ export interface IndicesSimulateIndexTemplate<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesSimulateTemplate<T = RequestBody> extends Generic {
+interface IndicesSimulateTemplateRequest<T = RequestBody> extends GenericRequest {
   name?: string;
   create?: boolean;
   cause?: string;
@@ -943,7 +943,7 @@ export interface IndicesSimulateTemplate<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesSplit<T = RequestBody> extends Generic {
+interface IndicesSplitRequest<T = RequestBody> extends GenericRequest {
   index: string;
   target: string;
   timeout?: string;
@@ -952,7 +952,7 @@ export interface IndicesSplit<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface IndicesStats extends Generic {
+interface IndicesStatsRequest extends GenericRequest {
   metric?: string | string[];
   index?: string | string[];
   completion_fields?: string | string[];
@@ -967,13 +967,13 @@ export interface IndicesStats extends Generic {
   forbid_closed_indices?: boolean;
 }
 
-export interface IndicesUpdateAliases<T = RequestBody> extends Generic {
+interface IndicesUpdateAliasesRequest<T = RequestBody> extends GenericRequest {
   timeout?: string;
   master_timeout?: string;
   body: T;
 }
 
-export interface IndicesUpgrade extends Generic {
+interface IndicesUpgradeRequest extends GenericRequest {
   index?: string | string[];
   allow_no_indices?: boolean;
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
@@ -982,7 +982,7 @@ export interface IndicesUpgrade extends Generic {
   only_ancient_segments?: boolean;
 }
 
-export interface IndicesValidateQuery<T = RequestBody> extends Generic {
+interface IndicesValidateQueryRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   type?: string | string[];
   explain?: boolean;
@@ -1000,37 +1000,37 @@ export interface IndicesValidateQuery<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface Info extends Generic {
+interface InfoRequest extends GenericRequest {
 }
 
-export interface IngestDeletePipeline extends Generic {
+interface IngestDeletePipelineRequest extends GenericRequest {
   id: string;
   master_timeout?: string;
   timeout?: string;
 }
 
-export interface IngestGetPipeline extends Generic {
+interface IngestGetPipelineRequest extends GenericRequest {
   id?: string;
   master_timeout?: string;
 }
 
-export interface IngestProcessorGrok extends Generic {
+interface IngestProcessorGrokRequest extends GenericRequest {
 }
 
-export interface IngestPutPipeline<T = RequestBody> extends Generic {
+interface IngestPutPipelineRequest<T = RequestBody> extends GenericRequest {
   id: string;
   master_timeout?: string;
   timeout?: string;
   body: T;
 }
 
-export interface IngestSimulate<T = RequestBody> extends Generic {
+interface IngestSimulateRequest<T = RequestBody> extends GenericRequest {
   id?: string;
   verbose?: boolean;
   body: T;
 }
 
-export interface Mget<T = RequestBody> extends Generic {
+interface MgetRequest<T = RequestBody> extends GenericRequest {
   index?: string;
   _source_exclude?: string | string[];
   _source_include?: string | string[];
@@ -1045,7 +1045,7 @@ export interface Mget<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface Msearch<T = RequestNDBody> extends Generic {
+interface MsearchRequest<T = RequestNDBody> extends GenericRequest {
   index?: string | string[];
   search_type?: 'query_then_fetch' | 'query_and_fetch' | 'dfs_query_then_fetch' | 'dfs_query_and_fetch';
   max_concurrent_searches?: number;
@@ -1057,7 +1057,7 @@ export interface Msearch<T = RequestNDBody> extends Generic {
   body: T;
 }
 
-export interface MsearchTemplate<T = RequestNDBody> extends Generic {
+interface MsearchTemplateRequest<T = RequestNDBody> extends GenericRequest {
   index?: string | string[];
   search_type?: 'query_then_fetch' | 'query_and_fetch' | 'dfs_query_then_fetch' | 'dfs_query_and_fetch';
   typed_keys?: boolean;
@@ -1067,7 +1067,7 @@ export interface MsearchTemplate<T = RequestNDBody> extends Generic {
   body: T;
 }
 
-export interface Mtermvectors<T = RequestBody> extends Generic {
+interface MtermvectorsRequest<T = RequestBody> extends GenericRequest {
   index?: string;
   ids?: string | string[];
   term_statistics?: boolean;
@@ -1084,7 +1084,7 @@ export interface Mtermvectors<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface NodesHotThreads extends Generic {
+interface NodesHotThreadsRequest extends GenericRequest {
   node_id?: string | string[];
   interval?: string;
   snapshots?: number;
@@ -1094,20 +1094,20 @@ export interface NodesHotThreads extends Generic {
   timeout?: string;
 }
 
-export interface NodesInfo extends Generic {
+interface NodesInfoRequest extends GenericRequest {
   node_id?: string | string[];
   metric?: string | string[];
   flat_settings?: boolean;
   timeout?: string;
 }
 
-export interface NodesReloadSecureSettings<T = RequestBody> extends Generic {
+interface NodesReloadSecureSettingsRequest<T = RequestBody> extends GenericRequest {
   node_id?: string | string[];
   timeout?: string;
   body?: T;
 }
 
-export interface NodesStats extends Generic {
+interface NodesStatsRequest extends GenericRequest {
   node_id?: string | string[];
   metric?: string | string[];
   index_metric?: string | string[];
@@ -1121,16 +1121,16 @@ export interface NodesStats extends Generic {
   include_segment_file_sizes?: boolean;
 }
 
-export interface NodesUsage extends Generic {
+interface NodesUsageRequest extends GenericRequest {
   node_id?: string | string[];
   metric?: string | string[];
   timeout?: string;
 }
 
-export interface Ping extends Generic {
+interface PingRequest extends GenericRequest {
 }
 
-export interface PutScript<T = RequestBody> extends Generic {
+interface PutScriptRequest<T = RequestBody> extends GenericRequest {
   id: string;
   context?: string;
   timeout?: string;
@@ -1138,7 +1138,7 @@ export interface PutScript<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface RankEval<T = RequestBody> extends Generic {
+interface RankEvalRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
@@ -1147,7 +1147,7 @@ export interface RankEval<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface Reindex<T = RequestBody> extends Generic {
+interface ReindexRequest<T = RequestBody> extends GenericRequest {
   refresh?: boolean;
   timeout?: string;
   wait_for_active_shards?: string;
@@ -1159,28 +1159,28 @@ export interface Reindex<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface ReindexRethrottle extends Generic {
+interface ReindexRethrottleRequest extends GenericRequest {
   task_id: string;
   requests_per_second: number;
 }
 
-export interface RenderSearchTemplate<T = RequestBody> extends Generic {
+interface RenderSearchTemplateRequest<T = RequestBody> extends GenericRequest {
   id?: string;
   body?: T;
 }
 
-export interface ScriptsPainlessExecute<T = RequestBody> extends Generic {
+interface ScriptsPainlessExecuteRequest<T = RequestBody> extends GenericRequest {
   body?: T;
 }
 
-export interface Scroll<T = RequestBody> extends Generic {
+interface ScrollRequest<T = RequestBody> extends GenericRequest {
   scroll_id?: string;
   scroll?: string;
   rest_total_hits_as_int?: boolean;
   body?: T;
 }
 
-export interface Search<T = RequestBody> extends Generic {
+interface SearchRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   _source_exclude?: string | string[];
   _source_include?: string | string[];
@@ -1229,7 +1229,7 @@ export interface Search<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface SearchShards extends Generic {
+interface SearchShardsRequest extends GenericRequest {
   index?: string | string[];
   preference?: string;
   routing?: string;
@@ -1239,7 +1239,7 @@ export interface SearchShards extends Generic {
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface SearchTemplate<T = RequestBody> extends Generic {
+interface SearchTemplateRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   ignore_throttled?: boolean;
@@ -1257,13 +1257,13 @@ export interface SearchTemplate<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface SnapshotCleanupRepository extends Generic {
+interface SnapshotCleanupRepositoryRequest extends GenericRequest {
   repository: string;
   master_timeout?: string;
   timeout?: string;
 }
 
-export interface SnapshotCreate<T = RequestBody> extends Generic {
+interface SnapshotCreateRequest<T = RequestBody> extends GenericRequest {
   repository: string;
   snapshot: string;
   master_timeout?: string;
@@ -1271,7 +1271,7 @@ export interface SnapshotCreate<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface SnapshotCreateRepository<T = RequestBody> extends Generic {
+interface SnapshotCreateRepositoryRequest<T = RequestBody> extends GenericRequest {
   repository: string;
   master_timeout?: string;
   timeout?: string;
@@ -1279,19 +1279,19 @@ export interface SnapshotCreateRepository<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface SnapshotDelete extends Generic {
+interface SnapshotDeleteRequest extends GenericRequest {
   repository: string;
   snapshot: string | string[];
   master_timeout?: string;
 }
 
-export interface SnapshotDeleteRepository extends Generic {
+interface SnapshotDeleteRepositoryRequest extends GenericRequest {
   repository: string | string[];
   master_timeout?: string;
   timeout?: string;
 }
 
-export interface SnapshotGet extends Generic {
+interface SnapshotGetRequest extends GenericRequest {
   repository: string;
   snapshot: string | string[];
   master_timeout?: string;
@@ -1299,13 +1299,13 @@ export interface SnapshotGet extends Generic {
   verbose?: boolean;
 }
 
-export interface SnapshotGetRepository extends Generic {
+interface SnapshotGetRepositoryRequest extends GenericRequest {
   repository?: string | string[];
   master_timeout?: string;
   local?: boolean;
 }
 
-export interface SnapshotRestore<T = RequestBody> extends Generic {
+interface SnapshotRestoreRequest<T = RequestBody> extends GenericRequest {
   repository: string;
   snapshot: string;
   master_timeout?: string;
@@ -1313,20 +1313,20 @@ export interface SnapshotRestore<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface SnapshotStatus extends Generic {
+interface SnapshotStatusRequest extends GenericRequest {
   repository?: string;
   snapshot?: string | string[];
   master_timeout?: string;
   ignore_unavailable?: boolean;
 }
 
-export interface SnapshotVerifyRepository extends Generic {
+interface SnapshotVerifyRepositoryRequest extends GenericRequest {
   repository: string;
   master_timeout?: string;
   timeout?: string;
 }
 
-export interface TasksCancel extends Generic {
+interface TasksCancelRequest extends GenericRequest {
   task_id?: string;
   nodes?: string | string[];
   actions?: string | string[];
@@ -1334,13 +1334,13 @@ export interface TasksCancel extends Generic {
   wait_for_completion?: boolean;
 }
 
-export interface TasksGet extends Generic {
+interface TasksGetRequest extends GenericRequest {
   task_id: string;
   wait_for_completion?: boolean;
   timeout?: string;
 }
 
-export interface TasksList extends Generic {
+interface TasksListRequest extends GenericRequest {
   nodes?: string | string[];
   actions?: string | string[];
   detailed?: boolean;
@@ -1350,7 +1350,7 @@ export interface TasksList extends Generic {
   timeout?: string;
 }
 
-export interface Termvectors<T = RequestBody> extends Generic {
+interface TermvectorsRequest<T = RequestBody> extends GenericRequest {
   index: string;
   id?: string;
   term_statistics?: boolean;
@@ -1367,7 +1367,7 @@ export interface Termvectors<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface Update<T = RequestBody> extends Generic {
+interface UpdateRequest<T = RequestBody> extends GenericRequest {
   id: string;
   index: string;
   type?: string;
@@ -1388,7 +1388,7 @@ export interface Update<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface UpdateByQuery<T = RequestBody> extends Generic {
+interface UpdateByQueryRequest<T = RequestBody> extends GenericRequest {
   index: string | string[];
   _source_exclude?: string | string[];
   _source_include?: string | string[];
@@ -1429,23 +1429,23 @@ export interface UpdateByQuery<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface UpdateByQueryRethrottle extends Generic {
+interface UpdateByQueryRethrottleRequest extends GenericRequest {
   task_id: string;
   requests_per_second: number;
 }
 
-export interface AsyncSearchDelete extends Generic {
+interface AsyncSearchDeleteRequest extends GenericRequest {
   id: string;
 }
 
-export interface AsyncSearchGet extends Generic {
+interface AsyncSearchGetRequest extends GenericRequest {
   id: string;
   wait_for_completion_timeout?: string;
   keep_alive?: string;
   typed_keys?: boolean;
 }
 
-export interface AsyncSearchSubmit<T = RequestBody> extends Generic {
+interface AsyncSearchSubmitRequest<T = RequestBody> extends GenericRequest {
   index?: string | string[];
   _source_exclude?: string | string[];
   _source_include?: string | string[];
@@ -1493,23 +1493,23 @@ export interface AsyncSearchSubmit<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface AutoscalingDeleteAutoscalingPolicy extends Generic {
+interface AutoscalingDeleteAutoscalingPolicyRequest extends GenericRequest {
   name: string;
 }
 
-export interface AutoscalingGetAutoscalingDecision extends Generic {
+interface AutoscalingGetAutoscalingDecisionRequest extends GenericRequest {
 }
 
-export interface AutoscalingGetAutoscalingPolicy extends Generic {
+interface AutoscalingGetAutoscalingPolicyRequest extends GenericRequest {
   name: string;
 }
 
-export interface AutoscalingPutAutoscalingPolicy<T = RequestBody> extends Generic {
+interface AutoscalingPutAutoscalingPolicyRequest<T = RequestBody> extends GenericRequest {
   name: string;
   body: T;
 }
 
-export interface CatMlDataFrameAnalytics extends Generic {
+interface CatMlDataFrameAnalyticsRequest extends GenericRequest {
   id?: string;
   allow_no_match?: boolean;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -1521,7 +1521,7 @@ export interface CatMlDataFrameAnalytics extends Generic {
   v?: boolean;
 }
 
-export interface CatMlDatafeeds extends Generic {
+interface CatMlDatafeedsRequest extends GenericRequest {
   datafeed_id?: string;
   allow_no_datafeeds?: boolean;
   format?: string;
@@ -1532,7 +1532,7 @@ export interface CatMlDatafeeds extends Generic {
   v?: boolean;
 }
 
-export interface CatMlJobs extends Generic {
+interface CatMlJobsRequest extends GenericRequest {
   job_id?: string;
   allow_no_jobs?: boolean;
   bytes?: 'b' | 'k' | 'kb' | 'm' | 'mb' | 'g' | 'gb' | 't' | 'tb' | 'p' | 'pb';
@@ -1544,7 +1544,7 @@ export interface CatMlJobs extends Generic {
   v?: boolean;
 }
 
-export interface CatMlTrainedModels extends Generic {
+interface CatMlTrainedModelsRequest extends GenericRequest {
   model_id?: string;
   allow_no_match?: boolean;
   from?: number;
@@ -1558,7 +1558,7 @@ export interface CatMlTrainedModels extends Generic {
   v?: boolean;
 }
 
-export interface CatTransforms extends Generic {
+interface CatTransformsRequest extends GenericRequest {
   transform_id?: string;
   from?: number;
   size?: number;
@@ -1571,141 +1571,141 @@ export interface CatTransforms extends Generic {
   v?: boolean;
 }
 
-export interface CcrDeleteAutoFollowPattern extends Generic {
+interface CcrDeleteAutoFollowPatternRequest extends GenericRequest {
   name: string;
 }
 
-export interface CcrFollow<T = RequestBody> extends Generic {
+interface CcrFollowRequest<T = RequestBody> extends GenericRequest {
   index: string;
   wait_for_active_shards?: string;
   body: T;
 }
 
-export interface CcrFollowInfo extends Generic {
+interface CcrFollowInfoRequest extends GenericRequest {
   index: string | string[];
 }
 
-export interface CcrFollowStats extends Generic {
+interface CcrFollowStatsRequest extends GenericRequest {
   index: string | string[];
 }
 
-export interface CcrForgetFollower<T = RequestBody> extends Generic {
+interface CcrForgetFollowerRequest<T = RequestBody> extends GenericRequest {
   index: string;
   body: T;
 }
 
-export interface CcrGetAutoFollowPattern extends Generic {
+interface CcrGetAutoFollowPatternRequest extends GenericRequest {
   name?: string;
 }
 
-export interface CcrPauseAutoFollowPattern extends Generic {
+interface CcrPauseAutoFollowPatternRequest extends GenericRequest {
   name: string;
 }
 
-export interface CcrPauseFollow extends Generic {
+interface CcrPauseFollowRequest extends GenericRequest {
   index: string;
 }
 
-export interface CcrPutAutoFollowPattern<T = RequestBody> extends Generic {
+interface CcrPutAutoFollowPatternRequest<T = RequestBody> extends GenericRequest {
   name: string;
   body: T;
 }
 
-export interface CcrResumeAutoFollowPattern extends Generic {
+interface CcrResumeAutoFollowPatternRequest extends GenericRequest {
   name: string;
 }
 
-export interface CcrResumeFollow<T = RequestBody> extends Generic {
+interface CcrResumeFollowRequest<T = RequestBody> extends GenericRequest {
   index: string;
   body?: T;
 }
 
-export interface CcrStats extends Generic {
+interface CcrStatsRequest extends GenericRequest {
 }
 
-export interface CcrUnfollow extends Generic {
+interface CcrUnfollowRequest extends GenericRequest {
   index: string;
 }
 
-export interface DataFrameTransformDeprecatedDeleteTransform extends Generic {
+interface DataFrameTransformDeprecatedDeleteTransformRequest extends GenericRequest {
   transform_id: string;
   force?: boolean;
 }
 
-export interface DataFrameTransformDeprecatedGetTransform extends Generic {
+interface DataFrameTransformDeprecatedGetTransformRequest extends GenericRequest {
   transform_id?: string;
   from?: number;
   size?: number;
   allow_no_match?: boolean;
 }
 
-export interface DataFrameTransformDeprecatedGetTransformStats extends Generic {
+interface DataFrameTransformDeprecatedGetTransformStatsRequest extends GenericRequest {
   transform_id: string;
   from?: number;
   size?: number;
   allow_no_match?: boolean;
 }
 
-export interface DataFrameTransformDeprecatedPreviewTransform<T = RequestBody> extends Generic {
+interface DataFrameTransformDeprecatedPreviewTransformRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface DataFrameTransformDeprecatedPutTransform<T = RequestBody> extends Generic {
+interface DataFrameTransformDeprecatedPutTransformRequest<T = RequestBody> extends GenericRequest {
   transform_id: string;
   defer_validation?: boolean;
   body: T;
 }
 
-export interface DataFrameTransformDeprecatedStartTransform extends Generic {
+interface DataFrameTransformDeprecatedStartTransformRequest extends GenericRequest {
   transform_id: string;
   timeout?: string;
 }
 
-export interface DataFrameTransformDeprecatedStopTransform extends Generic {
+interface DataFrameTransformDeprecatedStopTransformRequest extends GenericRequest {
   transform_id: string;
   wait_for_completion?: boolean;
   timeout?: string;
   allow_no_match?: boolean;
 }
 
-export interface DataFrameTransformDeprecatedUpdateTransform<T = RequestBody> extends Generic {
+interface DataFrameTransformDeprecatedUpdateTransformRequest<T = RequestBody> extends GenericRequest {
   transform_id: string;
   defer_validation?: boolean;
   body: T;
 }
 
-export interface EnrichDeletePolicy extends Generic {
+interface EnrichDeletePolicyRequest extends GenericRequest {
   name: string;
 }
 
-export interface EnrichExecutePolicy extends Generic {
+interface EnrichExecutePolicyRequest extends GenericRequest {
   name: string;
   wait_for_completion?: boolean;
 }
 
-export interface EnrichGetPolicy extends Generic {
+interface EnrichGetPolicyRequest extends GenericRequest {
   name?: string | string[];
 }
 
-export interface EnrichPutPolicy<T = RequestBody> extends Generic {
+interface EnrichPutPolicyRequest<T = RequestBody> extends GenericRequest {
   name: string;
   body: T;
 }
 
-export interface EnrichStats extends Generic {
+interface EnrichStatsRequest extends GenericRequest {
 }
 
-export interface EqlDelete extends Generic {
+interface EqlDeleteRequest extends GenericRequest {
   id: string;
 }
 
-export interface EqlGet extends Generic {
+interface EqlGetRequest extends GenericRequest {
   id: string;
   wait_for_completion_timeout?: string;
   keep_alive?: string;
 }
 
-export interface EqlSearch<T = RequestBody> extends Generic {
+interface EqlSearchRequest<T = RequestBody> extends GenericRequest {
   index: string;
   wait_for_completion_timeout?: string;
   keep_on_completion?: boolean;
@@ -1713,68 +1713,68 @@ export interface EqlSearch<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface GraphExplore<T = RequestBody> extends Generic {
+interface GraphExploreRequest<T = RequestBody> extends GenericRequest {
   index: string | string[];
   routing?: string;
   timeout?: string;
   body?: T;
 }
 
-export interface IlmDeleteLifecycle extends Generic {
+interface IlmDeleteLifecycleRequest extends GenericRequest {
   policy: string;
 }
 
-export interface IlmExplainLifecycle extends Generic {
+interface IlmExplainLifecycleRequest extends GenericRequest {
   index: string;
   only_managed?: boolean;
   only_errors?: boolean;
 }
 
-export interface IlmGetLifecycle extends Generic {
+interface IlmGetLifecycleRequest extends GenericRequest {
   policy?: string;
 }
 
-export interface IlmGetStatus extends Generic {
+interface IlmGetStatusRequest extends GenericRequest {
 }
 
-export interface IlmMoveToStep<T = RequestBody> extends Generic {
+interface IlmMoveToStepRequest<T = RequestBody> extends GenericRequest {
   index: string;
   body?: T;
 }
 
-export interface IlmPutLifecycle<T = RequestBody> extends Generic {
+interface IlmPutLifecycleRequest<T = RequestBody> extends GenericRequest {
   policy: string;
   body?: T;
 }
 
-export interface IlmRemovePolicy extends Generic {
+interface IlmRemovePolicyRequest extends GenericRequest {
   index: string;
 }
 
-export interface IlmRetry extends Generic {
+interface IlmRetryRequest extends GenericRequest {
   index: string;
 }
 
-export interface IlmStart extends Generic {
+interface IlmStartRequest extends GenericRequest {
 }
 
-export interface IlmStop extends Generic {
+interface IlmStopRequest extends GenericRequest {
 }
 
-export interface IndicesCreateDataStream<T = RequestBody> extends Generic {
+interface IndicesCreateDataStreamRequest<T = RequestBody> extends GenericRequest {
   name: string;
   body?: T;
 }
 
-export interface IndicesDataStreamsStats extends Generic {
+interface IndicesDataStreamsStatsRequest extends GenericRequest {
   name?: string | string[];
 }
 
-export interface IndicesDeleteDataStream extends Generic {
+interface IndicesDeleteDataStreamRequest extends GenericRequest {
   name: string | string[];
 }
 
-export interface IndicesFreeze extends Generic {
+interface IndicesFreezeRequest extends GenericRequest {
   index: string;
   timeout?: string;
   master_timeout?: string;
@@ -1784,18 +1784,18 @@ export interface IndicesFreeze extends Generic {
   wait_for_active_shards?: string;
 }
 
-export interface IndicesGetDataStream extends Generic {
+interface IndicesGetDataStreamRequest extends GenericRequest {
   name?: string | string[];
 }
 
-export interface IndicesReloadSearchAnalyzers extends Generic {
+interface IndicesReloadSearchAnalyzersRequest extends GenericRequest {
   index: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
   expand_wildcards?: 'open' | 'closed' | 'hidden' | 'none' | 'all';
 }
 
-export interface IndicesUnfreeze extends Generic {
+interface IndicesUnfreezeRequest extends GenericRequest {
   index: string;
   timeout?: string;
   master_timeout?: string;
@@ -1805,39 +1805,39 @@ export interface IndicesUnfreeze extends Generic {
   wait_for_active_shards?: string;
 }
 
-export interface LicenseDelete extends Generic {
+interface LicenseDeleteRequest extends GenericRequest {
 }
 
-export interface LicenseGet extends Generic {
+interface LicenseGetRequest extends GenericRequest {
   local?: boolean;
   accept_enterprise?: boolean;
 }
 
-export interface LicenseGetBasicStatus extends Generic {
+interface LicenseGetBasicStatusRequest extends GenericRequest {
 }
 
-export interface LicenseGetTrialStatus extends Generic {
+interface LicenseGetTrialStatusRequest extends GenericRequest {
 }
 
-export interface LicensePost<T = RequestBody> extends Generic {
+interface LicensePostRequest<T = RequestBody> extends GenericRequest {
   acknowledge?: boolean;
   body?: T;
 }
 
-export interface LicensePostStartBasic extends Generic {
+interface LicensePostStartBasicRequest extends GenericRequest {
   acknowledge?: boolean;
 }
 
-export interface LicensePostStartTrial extends Generic {
+interface LicensePostStartTrialRequest extends GenericRequest {
   type?: string;
   acknowledge?: boolean;
 }
 
-export interface MigrationDeprecations extends Generic {
+interface MigrationDeprecationsRequest extends GenericRequest {
   index?: string;
 }
 
-export interface MlCloseJob<T = RequestBody> extends Generic {
+interface MlCloseJobRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   allow_no_jobs?: boolean;
   force?: boolean;
@@ -1845,78 +1845,78 @@ export interface MlCloseJob<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlDeleteCalendar extends Generic {
+interface MlDeleteCalendarRequest extends GenericRequest {
   calendar_id: string;
 }
 
-export interface MlDeleteCalendarEvent extends Generic {
+interface MlDeleteCalendarEventRequest extends GenericRequest {
   calendar_id: string;
   event_id: string;
 }
 
-export interface MlDeleteCalendarJob extends Generic {
+interface MlDeleteCalendarJobRequest extends GenericRequest {
   calendar_id: string;
   job_id: string;
 }
 
-export interface MlDeleteDataFrameAnalytics extends Generic {
+interface MlDeleteDataFrameAnalyticsRequest extends GenericRequest {
   id: string;
   force?: boolean;
   timeout?: string;
 }
 
-export interface MlDeleteDatafeed extends Generic {
+interface MlDeleteDatafeedRequest extends GenericRequest {
   datafeed_id: string;
   force?: boolean;
 }
 
-export interface MlDeleteExpiredData<T = RequestBody> extends Generic {
+interface MlDeleteExpiredDataRequest<T = RequestBody> extends GenericRequest {
   job_id?: string;
   requests_per_second?: number;
   timeout?: string;
   body?: T;
 }
 
-export interface MlDeleteFilter extends Generic {
+interface MlDeleteFilterRequest extends GenericRequest {
   filter_id: string;
 }
 
-export interface MlDeleteForecast extends Generic {
+interface MlDeleteForecastRequest extends GenericRequest {
   job_id: string;
   forecast_id?: string;
   allow_no_forecasts?: boolean;
   timeout?: string;
 }
 
-export interface MlDeleteJob extends Generic {
+interface MlDeleteJobRequest extends GenericRequest {
   job_id: string;
   force?: boolean;
   wait_for_completion?: boolean;
 }
 
-export interface MlDeleteModelSnapshot extends Generic {
+interface MlDeleteModelSnapshotRequest extends GenericRequest {
   job_id: string;
   snapshot_id: string;
 }
 
-export interface MlDeleteTrainedModel extends Generic {
+interface MlDeleteTrainedModelRequest extends GenericRequest {
   model_id: string;
 }
 
-export interface MlEstimateModelMemory<T = RequestBody> extends Generic {
+interface MlEstimateModelMemoryRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface MlEvaluateDataFrame<T = RequestBody> extends Generic {
+interface MlEvaluateDataFrameRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface MlExplainDataFrameAnalytics<T = RequestBody> extends Generic {
+interface MlExplainDataFrameAnalyticsRequest<T = RequestBody> extends GenericRequest {
   id?: string;
   body?: T;
 }
 
-export interface MlFindFileStructure<T = RequestNDBody> extends Generic {
+interface MlFindFileStructureRequest<T = RequestNDBody> extends GenericRequest {
   lines_to_sample?: number;
   line_merge_size_limit?: number;
   timeout?: string;
@@ -1934,7 +1934,7 @@ export interface MlFindFileStructure<T = RequestNDBody> extends Generic {
   body: T;
 }
 
-export interface MlFlushJob<T = RequestBody> extends Generic {
+interface MlFlushJobRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   calc_interim?: boolean;
   start?: string;
@@ -1944,14 +1944,14 @@ export interface MlFlushJob<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlForecast extends Generic {
+interface MlForecastRequest extends GenericRequest {
   job_id: string;
   duration?: string;
   expires_in?: string;
   max_model_memory?: string;
 }
 
-export interface MlGetBuckets<T = RequestBody> extends Generic {
+interface MlGetBucketsRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   timestamp?: string;
   expand?: boolean;
@@ -1966,7 +1966,7 @@ export interface MlGetBuckets<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlGetCalendarEvents extends Generic {
+interface MlGetCalendarEventsRequest extends GenericRequest {
   calendar_id: string;
   job_id?: string;
   start?: string;
@@ -1975,14 +1975,14 @@ export interface MlGetCalendarEvents extends Generic {
   size?: number;
 }
 
-export interface MlGetCalendars<T = RequestBody> extends Generic {
+interface MlGetCalendarsRequest<T = RequestBody> extends GenericRequest {
   calendar_id?: string;
   from?: number;
   size?: number;
   body?: T;
 }
 
-export interface MlGetCategories<T = RequestBody> extends Generic {
+interface MlGetCategoriesRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   category_id?: number;
   from?: number;
@@ -1991,14 +1991,14 @@ export interface MlGetCategories<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlGetDataFrameAnalytics extends Generic {
+interface MlGetDataFrameAnalyticsRequest extends GenericRequest {
   id?: string;
   allow_no_match?: boolean;
   from?: number;
   size?: number;
 }
 
-export interface MlGetDataFrameAnalyticsStats extends Generic {
+interface MlGetDataFrameAnalyticsStatsRequest extends GenericRequest {
   id?: string;
   allow_no_match?: boolean;
   from?: number;
@@ -2006,23 +2006,23 @@ export interface MlGetDataFrameAnalyticsStats extends Generic {
   verbose?: boolean;
 }
 
-export interface MlGetDatafeedStats extends Generic {
+interface MlGetDatafeedStatsRequest extends GenericRequest {
   datafeed_id?: string;
   allow_no_datafeeds?: boolean;
 }
 
-export interface MlGetDatafeeds extends Generic {
+interface MlGetDatafeedsRequest extends GenericRequest {
   datafeed_id?: string;
   allow_no_datafeeds?: boolean;
 }
 
-export interface MlGetFilters extends Generic {
+interface MlGetFiltersRequest extends GenericRequest {
   filter_id?: string;
   from?: number;
   size?: number;
 }
 
-export interface MlGetInfluencers<T = RequestBody> extends Generic {
+interface MlGetInfluencersRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   exclude_interim?: boolean;
   from?: number;
@@ -2035,17 +2035,17 @@ export interface MlGetInfluencers<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlGetJobStats extends Generic {
+interface MlGetJobStatsRequest extends GenericRequest {
   job_id?: string;
   allow_no_jobs?: boolean;
 }
 
-export interface MlGetJobs extends Generic {
+interface MlGetJobsRequest extends GenericRequest {
   job_id?: string;
   allow_no_jobs?: boolean;
 }
 
-export interface MlGetModelSnapshots<T = RequestBody> extends Generic {
+interface MlGetModelSnapshotsRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   snapshot_id?: string;
   from?: number;
@@ -2057,7 +2057,7 @@ export interface MlGetModelSnapshots<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlGetOverallBuckets<T = RequestBody> extends Generic {
+interface MlGetOverallBucketsRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   top_n?: number;
   bucket_span?: string;
@@ -2069,7 +2069,7 @@ export interface MlGetOverallBuckets<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlGetRecords<T = RequestBody> extends Generic {
+interface MlGetRecordsRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   exclude_interim?: boolean;
   from?: number;
@@ -2082,7 +2082,7 @@ export interface MlGetRecords<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlGetTrainedModels extends Generic {
+interface MlGetTrainedModelsRequest extends GenericRequest {
   model_id?: string;
   allow_no_match?: boolean;
   include_model_definition?: boolean;
@@ -2093,52 +2093,52 @@ export interface MlGetTrainedModels extends Generic {
   for_export?: boolean;
 }
 
-export interface MlGetTrainedModelsStats extends Generic {
+interface MlGetTrainedModelsStatsRequest extends GenericRequest {
   model_id?: string;
   allow_no_match?: boolean;
   from?: number;
   size?: number;
 }
 
-export interface MlInfo extends Generic {
+interface MlInfoRequest extends GenericRequest {
 }
 
-export interface MlOpenJob extends Generic {
+interface MlOpenJobRequest extends GenericRequest {
   job_id: string;
 }
 
-export interface MlPostCalendarEvents<T = RequestBody> extends Generic {
+interface MlPostCalendarEventsRequest<T = RequestBody> extends GenericRequest {
   calendar_id: string;
   body: T;
 }
 
-export interface MlPostData<T = RequestBody> extends Generic {
+interface MlPostDataRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   reset_start?: string;
   reset_end?: string;
   body: T;
 }
 
-export interface MlPreviewDatafeed extends Generic {
+interface MlPreviewDatafeedRequest extends GenericRequest {
   datafeed_id: string;
 }
 
-export interface MlPutCalendar<T = RequestBody> extends Generic {
+interface MlPutCalendarRequest<T = RequestBody> extends GenericRequest {
   calendar_id: string;
   body?: T;
 }
 
-export interface MlPutCalendarJob extends Generic {
+interface MlPutCalendarJobRequest extends GenericRequest {
   calendar_id: string;
   job_id: string;
 }
 
-export interface MlPutDataFrameAnalytics<T = RequestBody> extends Generic {
+interface MlPutDataFrameAnalyticsRequest<T = RequestBody> extends GenericRequest {
   id: string;
   body: T;
 }
 
-export interface MlPutDatafeed<T = RequestBody> extends Generic {
+interface MlPutDatafeedRequest<T = RequestBody> extends GenericRequest {
   datafeed_id: string;
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
@@ -2147,40 +2147,40 @@ export interface MlPutDatafeed<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface MlPutFilter<T = RequestBody> extends Generic {
+interface MlPutFilterRequest<T = RequestBody> extends GenericRequest {
   filter_id: string;
   body: T;
 }
 
-export interface MlPutJob<T = RequestBody> extends Generic {
+interface MlPutJobRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   body: T;
 }
 
-export interface MlPutTrainedModel<T = RequestBody> extends Generic {
+interface MlPutTrainedModelRequest<T = RequestBody> extends GenericRequest {
   model_id: string;
   body: T;
 }
 
-export interface MlRevertModelSnapshot<T = RequestBody> extends Generic {
+interface MlRevertModelSnapshotRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   snapshot_id: string;
   delete_intervening_results?: boolean;
   body?: T;
 }
 
-export interface MlSetUpgradeMode extends Generic {
+interface MlSetUpgradeModeRequest extends GenericRequest {
   enabled?: boolean;
   timeout?: string;
 }
 
-export interface MlStartDataFrameAnalytics<T = RequestBody> extends Generic {
+interface MlStartDataFrameAnalyticsRequest<T = RequestBody> extends GenericRequest {
   id: string;
   timeout?: string;
   body?: T;
 }
 
-export interface MlStartDatafeed<T = RequestBody> extends Generic {
+interface MlStartDatafeedRequest<T = RequestBody> extends GenericRequest {
   datafeed_id: string;
   start?: string;
   end?: string;
@@ -2188,7 +2188,7 @@ export interface MlStartDatafeed<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlStopDataFrameAnalytics<T = RequestBody> extends Generic {
+interface MlStopDataFrameAnalyticsRequest<T = RequestBody> extends GenericRequest {
   id: string;
   allow_no_match?: boolean;
   force?: boolean;
@@ -2196,19 +2196,19 @@ export interface MlStopDataFrameAnalytics<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface MlStopDatafeed extends Generic {
+interface MlStopDatafeedRequest extends GenericRequest {
   datafeed_id: string;
   allow_no_datafeeds?: boolean;
   force?: boolean;
   timeout?: string;
 }
 
-export interface MlUpdateDataFrameAnalytics<T = RequestBody> extends Generic {
+interface MlUpdateDataFrameAnalyticsRequest<T = RequestBody> extends GenericRequest {
   id: string;
   body: T;
 }
 
-export interface MlUpdateDatafeed<T = RequestBody> extends Generic {
+interface MlUpdateDatafeedRequest<T = RequestBody> extends GenericRequest {
   datafeed_id: string;
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
@@ -2217,31 +2217,31 @@ export interface MlUpdateDatafeed<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface MlUpdateFilter<T = RequestBody> extends Generic {
+interface MlUpdateFilterRequest<T = RequestBody> extends GenericRequest {
   filter_id: string;
   body: T;
 }
 
-export interface MlUpdateJob<T = RequestBody> extends Generic {
+interface MlUpdateJobRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   body: T;
 }
 
-export interface MlUpdateModelSnapshot<T = RequestBody> extends Generic {
+interface MlUpdateModelSnapshotRequest<T = RequestBody> extends GenericRequest {
   job_id: string;
   snapshot_id: string;
   body: T;
 }
 
-export interface MlValidate<T = RequestBody> extends Generic {
+interface MlValidateRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface MlValidateDetector<T = RequestBody> extends Generic {
+interface MlValidateDetectorRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface MonitoringBulk<T = RequestNDBody> extends Generic {
+interface MonitoringBulkRequest<T = RequestNDBody> extends GenericRequest {
   type?: string;
   system_id?: string;
   system_api_version?: string;
@@ -2249,28 +2249,28 @@ export interface MonitoringBulk<T = RequestNDBody> extends Generic {
   body: T;
 }
 
-export interface RollupDeleteJob extends Generic {
+interface RollupDeleteJobRequest extends GenericRequest {
   id: string;
 }
 
-export interface RollupGetJobs extends Generic {
+interface RollupGetJobsRequest extends GenericRequest {
   id?: string;
 }
 
-export interface RollupGetRollupCaps extends Generic {
+interface RollupGetRollupCapsRequest extends GenericRequest {
   id?: string;
 }
 
-export interface RollupGetRollupIndexCaps extends Generic {
+interface RollupGetRollupIndexCapsRequest extends GenericRequest {
   index: string;
 }
 
-export interface RollupPutJob<T = RequestBody> extends Generic {
+interface RollupPutJobRequest<T = RequestBody> extends GenericRequest {
   id: string;
   body: T;
 }
 
-export interface RollupRollupSearch<T = RequestBody> extends Generic {
+interface RollupRollupSearchRequest<T = RequestBody> extends GenericRequest {
   index: string | string[];
   type?: string;
   typed_keys?: boolean;
@@ -2278,24 +2278,24 @@ export interface RollupRollupSearch<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface RollupStartJob extends Generic {
+interface RollupStartJobRequest extends GenericRequest {
   id: string;
 }
 
-export interface RollupStopJob extends Generic {
+interface RollupStopJobRequest extends GenericRequest {
   id: string;
   wait_for_completion?: boolean;
   timeout?: string;
 }
 
-export interface SearchableSnapshotsClearCache extends Generic {
+interface SearchableSnapshotsClearCacheRequest extends GenericRequest {
   index?: string | string[];
   ignore_unavailable?: boolean;
   allow_no_indices?: boolean;
   expand_wildcards?: 'open' | 'closed' | 'none' | 'all';
 }
 
-export interface SearchableSnapshotsMount<T = RequestBody> extends Generic {
+interface SearchableSnapshotsMountRequest<T = RequestBody> extends GenericRequest {
   repository: string;
   snapshot: string;
   master_timeout?: string;
@@ -2303,73 +2303,73 @@ export interface SearchableSnapshotsMount<T = RequestBody> extends Generic {
   body: T;
 }
 
-export interface SearchableSnapshotsRepositoryStats extends Generic {
+interface SearchableSnapshotsRepositoryStatsRequest extends GenericRequest {
   repository: string;
 }
 
-export interface SearchableSnapshotsStats extends Generic {
+interface SearchableSnapshotsStatsRequest extends GenericRequest {
   index?: string | string[];
 }
 
-export interface SecurityAuthenticate extends Generic {
+interface SecurityAuthenticateRequest extends GenericRequest {
 }
 
-export interface SecurityChangePassword<T = RequestBody> extends Generic {
+interface SecurityChangePasswordRequest<T = RequestBody> extends GenericRequest {
   username?: string;
   refresh?: 'wait_for' | boolean;
   body: T;
 }
 
-export interface SecurityClearCachedPrivileges extends Generic {
+interface SecurityClearCachedPrivilegesRequest extends GenericRequest {
   application: string | string[];
 }
 
-export interface SecurityClearCachedRealms extends Generic {
+interface SecurityClearCachedRealmsRequest extends GenericRequest {
   realms: string | string[];
   usernames?: string | string[];
 }
 
-export interface SecurityClearCachedRoles extends Generic {
+interface SecurityClearCachedRolesRequest extends GenericRequest {
   name: string | string[];
 }
 
-export interface SecurityCreateApiKey<T = RequestBody> extends Generic {
+interface SecurityCreateApiKeyRequest<T = RequestBody> extends GenericRequest {
   refresh?: 'wait_for' | boolean;
   body: T;
 }
 
-export interface SecurityDeletePrivileges extends Generic {
+interface SecurityDeletePrivilegesRequest extends GenericRequest {
   application: string;
   name: string;
   refresh?: 'wait_for' | boolean;
 }
 
-export interface SecurityDeleteRole extends Generic {
+interface SecurityDeleteRoleRequest extends GenericRequest {
   name: string;
   refresh?: 'wait_for' | boolean;
 }
 
-export interface SecurityDeleteRoleMapping extends Generic {
+interface SecurityDeleteRoleMappingRequest extends GenericRequest {
   name: string;
   refresh?: 'wait_for' | boolean;
 }
 
-export interface SecurityDeleteUser extends Generic {
+interface SecurityDeleteUserRequest extends GenericRequest {
   username: string;
   refresh?: 'wait_for' | boolean;
 }
 
-export interface SecurityDisableUser extends Generic {
+interface SecurityDisableUserRequest extends GenericRequest {
   username: string;
   refresh?: 'wait_for' | boolean;
 }
 
-export interface SecurityEnableUser extends Generic {
+interface SecurityEnableUserRequest extends GenericRequest {
   username: string;
   refresh?: 'wait_for' | boolean;
 }
 
-export interface SecurityGetApiKey extends Generic {
+interface SecurityGetApiKeyRequest extends GenericRequest {
   id?: string;
   name?: string;
   username?: string;
@@ -2377,152 +2377,152 @@ export interface SecurityGetApiKey extends Generic {
   owner?: boolean;
 }
 
-export interface SecurityGetBuiltinPrivileges extends Generic {
+interface SecurityGetBuiltinPrivilegesRequest extends GenericRequest {
 }
 
-export interface SecurityGetPrivileges extends Generic {
+interface SecurityGetPrivilegesRequest extends GenericRequest {
   application?: string;
   name?: string;
 }
 
-export interface SecurityGetRole extends Generic {
+interface SecurityGetRoleRequest extends GenericRequest {
   name?: string | string[];
 }
 
-export interface SecurityGetRoleMapping extends Generic {
+interface SecurityGetRoleMappingRequest extends GenericRequest {
   name?: string | string[];
 }
 
-export interface SecurityGetToken<T = RequestBody> extends Generic {
+interface SecurityGetTokenRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface SecurityGetUser extends Generic {
+interface SecurityGetUserRequest extends GenericRequest {
   username?: string | string[];
 }
 
-export interface SecurityGetUserPrivileges extends Generic {
+interface SecurityGetUserPrivilegesRequest extends GenericRequest {
 }
 
-export interface SecurityHasPrivileges<T = RequestBody> extends Generic {
+interface SecurityHasPrivilegesRequest<T = RequestBody> extends GenericRequest {
   user?: string;
   body: T;
 }
 
-export interface SecurityInvalidateApiKey<T = RequestBody> extends Generic {
+interface SecurityInvalidateApiKeyRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface SecurityInvalidateToken<T = RequestBody> extends Generic {
+interface SecurityInvalidateTokenRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface SecurityPutPrivileges<T = RequestBody> extends Generic {
+interface SecurityPutPrivilegesRequest<T = RequestBody> extends GenericRequest {
   refresh?: 'wait_for' | boolean;
   body: T;
 }
 
-export interface SecurityPutRole<T = RequestBody> extends Generic {
+interface SecurityPutRoleRequest<T = RequestBody> extends GenericRequest {
   name: string;
   refresh?: 'wait_for' | boolean;
   body: T;
 }
 
-export interface SecurityPutRoleMapping<T = RequestBody> extends Generic {
+interface SecurityPutRoleMappingRequest<T = RequestBody> extends GenericRequest {
   name: string;
   refresh?: 'wait_for' | boolean;
   body: T;
 }
 
-export interface SecurityPutUser<T = RequestBody> extends Generic {
+interface SecurityPutUserRequest<T = RequestBody> extends GenericRequest {
   username: string;
   refresh?: 'wait_for' | boolean;
   body: T;
 }
 
-export interface SlmDeleteLifecycle extends Generic {
+interface SlmDeleteLifecycleRequest extends GenericRequest {
   policy_id: string;
 }
 
-export interface SlmExecuteLifecycle extends Generic {
+interface SlmExecuteLifecycleRequest extends GenericRequest {
   policy_id: string;
 }
 
-export interface SlmExecuteRetention extends Generic {
+interface SlmExecuteRetentionRequest extends GenericRequest {
 }
 
-export interface SlmGetLifecycle extends Generic {
+interface SlmGetLifecycleRequest extends GenericRequest {
   policy_id?: string | string[];
 }
 
-export interface SlmGetStats extends Generic {
+interface SlmGetStatsRequest extends GenericRequest {
 }
 
-export interface SlmGetStatus extends Generic {
+interface SlmGetStatusRequest extends GenericRequest {
 }
 
-export interface SlmPutLifecycle<T = RequestBody> extends Generic {
+interface SlmPutLifecycleRequest<T = RequestBody> extends GenericRequest {
   policy_id: string;
   body?: T;
 }
 
-export interface SlmStart extends Generic {
+interface SlmStartRequest extends GenericRequest {
 }
 
-export interface SlmStop extends Generic {
+interface SlmStopRequest extends GenericRequest {
 }
 
-export interface SqlClearCursor<T = RequestBody> extends Generic {
+interface SqlClearCursorRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface SqlQuery<T = RequestBody> extends Generic {
+interface SqlQueryRequest<T = RequestBody> extends GenericRequest {
   format?: string;
   body: T;
 }
 
-export interface SqlTranslate<T = RequestBody> extends Generic {
+interface SqlTranslateRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface SslCertificates extends Generic {
+interface SslCertificatesRequest extends GenericRequest {
 }
 
-export interface TransformDeleteTransform extends Generic {
+interface TransformDeleteTransformRequest extends GenericRequest {
   transform_id: string;
   force?: boolean;
 }
 
-export interface TransformGetTransform extends Generic {
+interface TransformGetTransformRequest extends GenericRequest {
   transform_id?: string;
   from?: number;
   size?: number;
   allow_no_match?: boolean;
 }
 
-export interface TransformGetTransformStats extends Generic {
+interface TransformGetTransformStatsRequest extends GenericRequest {
   transform_id: string;
   from?: number;
   size?: number;
   allow_no_match?: boolean;
 }
 
-export interface TransformPreviewTransform<T = RequestBody> extends Generic {
+interface TransformPreviewTransformRequest<T = RequestBody> extends GenericRequest {
   body: T;
 }
 
-export interface TransformPutTransform<T = RequestBody> extends Generic {
+interface TransformPutTransformRequest<T = RequestBody> extends GenericRequest {
   transform_id: string;
   defer_validation?: boolean;
   body: T;
 }
 
-export interface TransformStartTransform extends Generic {
+interface TransformStartTransformRequest extends GenericRequest {
   transform_id: string;
   timeout?: string;
 }
 
-export interface TransformStopTransform extends Generic {
+interface TransformStopTransformRequest extends GenericRequest {
   transform_id: string;
   force?: boolean;
   wait_for_completion?: boolean;
@@ -2531,40 +2531,40 @@ export interface TransformStopTransform extends Generic {
   wait_for_checkpoint?: boolean;
 }
 
-export interface TransformUpdateTransform<T = RequestBody> extends Generic {
+interface TransformUpdateTransformRequest<T = RequestBody> extends GenericRequest {
   transform_id: string;
   defer_validation?: boolean;
   body: T;
 }
 
-export interface WatcherAckWatch extends Generic {
+interface WatcherAckWatchRequest extends GenericRequest {
   watch_id: string;
   action_id?: string | string[];
 }
 
-export interface WatcherActivateWatch extends Generic {
+interface WatcherActivateWatchRequest extends GenericRequest {
   watch_id: string;
 }
 
-export interface WatcherDeactivateWatch extends Generic {
+interface WatcherDeactivateWatchRequest extends GenericRequest {
   watch_id: string;
 }
 
-export interface WatcherDeleteWatch extends Generic {
+interface WatcherDeleteWatchRequest extends GenericRequest {
   id: string;
 }
 
-export interface WatcherExecuteWatch<T = RequestBody> extends Generic {
+interface WatcherExecuteWatchRequest<T = RequestBody> extends GenericRequest {
   id?: string;
   debug?: boolean;
   body?: T;
 }
 
-export interface WatcherGetWatch extends Generic {
+interface WatcherGetWatchRequest extends GenericRequest {
   id: string;
 }
 
-export interface WatcherPutWatch<T = RequestBody> extends Generic {
+interface WatcherPutWatchRequest<T = RequestBody> extends GenericRequest {
   id: string;
   active?: boolean;
   version?: number;
@@ -2573,22 +2573,111 @@ export interface WatcherPutWatch<T = RequestBody> extends Generic {
   body?: T;
 }
 
-export interface WatcherStart extends Generic {
+interface WatcherStartRequest extends GenericRequest {
 }
 
-export interface WatcherStats extends Generic {
+interface WatcherStatsRequest extends GenericRequest {
   metric?: string | string[];
   emit_stacktraces?: boolean;
 }
 
-export interface WatcherStop extends Generic {
+interface WatcherStopRequest extends GenericRequest {
 }
 
-export interface XpackInfo extends Generic {
+interface XpackInfoRequest extends GenericRequest {
   categories?: string | string[];
   accept_enterprise?: boolean;
 }
 
-export interface XpackUsage extends Generic {
-  master_timeout?: string;
-}
+interface XpackUsageRequest extends GenericRequest {
+  master_timeout?: string;
+}
+
+export {
+  BulkRequest, CatAliasesRequest, CatAllocationRequest, CatCountRequest,
+  CatFielddataRequest, CatHealthRequest, CatHelpRequest, CatIndicesRequest,
+  CatMasterRequest, CatNodeattrsRequest, CatNodesRequest, CatPendingTasksRequest,
+  CatPluginsRequest, CatRecoveryRequest, CatRepositoriesRequest, CatSegmentsRequest,
+  CatShardsRequest, CatSnapshotsRequest, CatTasksRequest, CatTemplatesRequest,
+  CatThreadPoolRequest, ClearScrollRequest, ClusterAllocationExplainRequest, ClusterDeleteComponentTemplateRequest,
+  ClusterDeleteVotingConfigExclusionsRequest, ClusterExistsComponentTemplateRequest, ClusterGetComponentTemplateRequest, ClusterGetSettingsRequest,
+  ClusterHealthRequest, ClusterPendingTasksRequest, ClusterPostVotingConfigExclusionsRequest, ClusterPutComponentTemplateRequest,
+  ClusterPutSettingsRequest, ClusterRemoteInfoRequest, ClusterRerouteRequest, ClusterStateRequest,
+  ClusterStatsRequest, CountRequest, CreateRequest, DanglingIndicesDeleteDanglingIndexRequest,
+  DanglingIndicesImportDanglingIndexRequest, DanglingIndicesListDanglingIndicesRequest, DeleteRequest, DeleteByQueryRequest,
+  DeleteByQueryRethrottleRequest, DeleteScriptRequest, ExistsRequest, ExistsSourceRequest,
+  ExplainRequest, FieldCapsRequest, GetRequest, GetScriptRequest,
+  GetScriptContextRequest, GetScriptLanguagesRequest, GetSourceRequest, IndexRequest,
+  IndicesAddBlockRequest, IndicesAnalyzeRequest, IndicesClearCacheRequest, IndicesCloneRequest,
+  IndicesCloseRequest, IndicesCreateRequest, IndicesDeleteRequest, IndicesDeleteAliasRequest,
+  IndicesDeleteIndexTemplateRequest, IndicesDeleteTemplateRequest, IndicesExistsRequest, IndicesExistsAliasRequest,
+  IndicesExistsIndexTemplateRequest, IndicesExistsTemplateRequest, IndicesExistsTypeRequest, IndicesFlushRequest,
+  IndicesForcemergeRequest, IndicesGetRequest, IndicesGetAliasRequest, IndicesGetFieldMappingRequest,
+  IndicesGetIndexTemplateRequest, IndicesGetMappingRequest, IndicesGetSettingsRequest, IndicesGetTemplateRequest,
+  IndicesGetUpgradeRequest, IndicesOpenRequest, IndicesPutAliasRequest, IndicesPutIndexTemplateRequest,
+  IndicesPutMappingRequest, IndicesPutSettingsRequest, IndicesPutTemplateRequest, IndicesRecoveryRequest,
+  IndicesRefreshRequest, IndicesResolveIndexRequest, IndicesRolloverRequest, IndicesSegmentsRequest,
+  IndicesShardStoresRequest, IndicesShrinkRequest, IndicesSimulateIndexTemplateRequest, IndicesSimulateTemplateRequest,
+  IndicesSplitRequest, IndicesStatsRequest, IndicesUpdateAliasesRequest, IndicesUpgradeRequest,
+  IndicesValidateQueryRequest, InfoRequest, IngestDeletePipelineRequest, IngestGetPipelineRequest,
+  IngestProcessorGrokRequest, IngestPutPipelineRequest, IngestSimulateRequest, MgetRequest,
+  MsearchRequest, MsearchTemplateRequest, MtermvectorsRequest, NodesHotThreadsRequest,
+  NodesInfoRequest, NodesReloadSecureSettingsRequest, NodesStatsRequest, NodesUsageRequest,
+  PingRequest, PutScriptRequest, RankEvalRequest, ReindexRequest,
+  ReindexRethrottleRequest, RenderSearchTemplateRequest, ScriptsPainlessExecuteRequest, ScrollRequest,
+  SearchRequest, SearchShardsRequest, SearchTemplateRequest, SnapshotCleanupRepositoryRequest,
+  SnapshotCreateRequest, SnapshotCreateRepositoryRequest, SnapshotDeleteRequest, SnapshotDeleteRepositoryRequest,
+  SnapshotGetRequest, SnapshotGetRepositoryRequest, SnapshotRestoreRequest, SnapshotStatusRequest,
+  SnapshotVerifyRepositoryRequest, TasksCancelRequest, TasksGetRequest, TasksListRequest,
+  TermvectorsRequest, UpdateRequest, UpdateByQueryRequest, UpdateByQueryRethrottleRequest,
+  AsyncSearchDeleteRequest, AsyncSearchGetRequest, AsyncSearchSubmitRequest, AutoscalingDeleteAutoscalingPolicyRequest,
+  AutoscalingGetAutoscalingDecisionRequest, AutoscalingGetAutoscalingPolicyRequest, AutoscalingPutAutoscalingPolicyRequest, CatMlDataFrameAnalyticsRequest,
+  CatMlDatafeedsRequest, CatMlJobsRequest, CatMlTrainedModelsRequest, CatTransformsRequest,
+  CcrDeleteAutoFollowPatternRequest, CcrFollowRequest, CcrFollowInfoRequest, CcrFollowStatsRequest,
+  CcrForgetFollowerRequest, CcrGetAutoFollowPatternRequest, CcrPauseAutoFollowPatternRequest, CcrPauseFollowRequest,
+  CcrPutAutoFollowPatternRequest, CcrResumeAutoFollowPatternRequest, CcrResumeFollowRequest, CcrStatsRequest,
+  CcrUnfollowRequest, DataFrameTransformDeprecatedDeleteTransformRequest, DataFrameTransformDeprecatedGetTransformRequest, DataFrameTransformDeprecatedGetTransformStatsRequest,
+  DataFrameTransformDeprecatedPreviewTransformRequest, DataFrameTransformDeprecatedPutTransformRequest, DataFrameTransformDeprecatedStartTransformRequest, DataFrameTransformDeprecatedStopTransformRequest,
+  DataFrameTransformDeprecatedUpdateTransformRequest, EnrichDeletePolicyRequest, EnrichExecutePolicyRequest, EnrichGetPolicyRequest,
+  EnrichPutPolicyRequest, EnrichStatsRequest, EqlDeleteRequest, EqlGetRequest,
+  EqlSearchRequest, GraphExploreRequest, IlmDeleteLifecycleRequest, IlmExplainLifecycleRequest,
+  IlmGetLifecycleRequest, IlmGetStatusRequest, IlmMoveToStepRequest, IlmPutLifecycleRequest,
+  IlmRemovePolicyRequest, IlmRetryRequest, IlmStartRequest, IlmStopRequest,
+  IndicesCreateDataStreamRequest, IndicesDataStreamsStatsRequest, IndicesDeleteDataStreamRequest, IndicesFreezeRequest,
+  IndicesGetDataStreamRequest, IndicesReloadSearchAnalyzersRequest, IndicesUnfreezeRequest, LicenseDeleteRequest,
+  LicenseGetRequest, LicenseGetBasicStatusRequest, LicenseGetTrialStatusRequest, LicensePostRequest,
+  LicensePostStartBasicRequest, LicensePostStartTrialRequest, MigrationDeprecationsRequest, MlCloseJobRequest,
+  MlDeleteCalendarRequest, MlDeleteCalendarEventRequest, MlDeleteCalendarJobRequest, MlDeleteDataFrameAnalyticsRequest,
+  MlDeleteDatafeedRequest, MlDeleteExpiredDataRequest, MlDeleteFilterRequest, MlDeleteForecastRequest,
+  MlDeleteJobRequest, MlDeleteModelSnapshotRequest, MlDeleteTrainedModelRequest, MlEstimateModelMemoryRequest,
+  MlEvaluateDataFrameRequest, MlExplainDataFrameAnalyticsRequest, MlFindFileStructureRequest, MlFlushJobRequest,
+  MlForecastRequest, MlGetBucketsRequest, MlGetCalendarEventsRequest, MlGetCalendarsRequest,
+  MlGetCategoriesRequest, MlGetDataFrameAnalyticsRequest, MlGetDataFrameAnalyticsStatsRequest, MlGetDatafeedStatsRequest,
+  MlGetDatafeedsRequest, MlGetFiltersRequest, MlGetInfluencersRequest, MlGetJobStatsRequest,
+  MlGetJobsRequest, MlGetModelSnapshotsRequest, MlGetOverallBucketsRequest, MlGetRecordsRequest,
+  MlGetTrainedModelsRequest, MlGetTrainedModelsStatsRequest, MlInfoRequest, MlOpenJobRequest,
+  MlPostCalendarEventsRequest, MlPostDataRequest, MlPreviewDatafeedRequest, MlPutCalendarRequest,
+  MlPutCalendarJobRequest, MlPutDataFrameAnalyticsRequest, MlPutDatafeedRequest, MlPutFilterRequest,
+  MlPutJobRequest, MlPutTrainedModelRequest, MlRevertModelSnapshotRequest, MlSetUpgradeModeRequest,
+  MlStartDataFrameAnalyticsRequest, MlStartDatafeedRequest, MlStopDataFrameAnalyticsRequest, MlStopDatafeedRequest,
+  MlUpdateDataFrameAnalyticsRequest, MlUpdateDatafeedRequest, MlUpdateFilterRequest, MlUpdateJobRequest,
+  MlUpdateModelSnapshotRequest, MlValidateRequest, MlValidateDetectorRequest, MonitoringBulkRequest,
+  RollupDeleteJobRequest, RollupGetJobsRequest, RollupGetRollupCapsRequest, RollupGetRollupIndexCapsRequest,
+  RollupPutJobRequest, RollupRollupSearchRequest, RollupStartJobRequest, RollupStopJobRequest,
+  SearchableSnapshotsClearCacheRequest, SearchableSnapshotsMountRequest, SearchableSnapshotsRepositoryStatsRequest, SearchableSnapshotsStatsRequest,
+  SecurityAuthenticateRequest, SecurityChangePasswordRequest, SecurityClearCachedPrivilegesRequest, SecurityClearCachedRealmsRequest,
+  SecurityClearCachedRolesRequest, SecurityCreateApiKeyRequest, SecurityDeletePrivilegesRequest, SecurityDeleteRoleRequest,
+  SecurityDeleteRoleMappingRequest, SecurityDeleteUserRequest, SecurityDisableUserRequest, SecurityEnableUserRequest,
+  SecurityGetApiKeyRequest, SecurityGetBuiltinPrivilegesRequest, SecurityGetPrivilegesRequest, SecurityGetRoleRequest,
+  SecurityGetRoleMappingRequest, SecurityGetTokenRequest, SecurityGetUserRequest, SecurityGetUserPrivilegesRequest,
+  SecurityHasPrivilegesRequest, SecurityInvalidateApiKeyRequest, SecurityInvalidateTokenRequest, SecurityPutPrivilegesRequest,
+  SecurityPutRoleRequest, SecurityPutRoleMappingRequest, SecurityPutUserRequest, SlmDeleteLifecycleRequest,
+  SlmExecuteLifecycleRequest, SlmExecuteRetentionRequest, SlmGetLifecycleRequest, SlmGetStatsRequest,
+  SlmGetStatusRequest, SlmPutLifecycleRequest, SlmStartRequest, SlmStopRequest,
+  SqlClearCursorRequest, SqlQueryRequest, SqlTranslateRequest, SslCertificatesRequest,
+  TransformDeleteTransformRequest, TransformGetTransformRequest, TransformGetTransformStatsRequest, TransformPreviewTransformRequest,
+  TransformPutTransformRequest, TransformStartTransformRequest, TransformStopTransformRequest, TransformUpdateTransformRequest,
+  WatcherAckWatchRequest, WatcherActivateWatchRequest, WatcherDeactivateWatchRequest, WatcherDeleteWatchRequest,
+  WatcherExecuteWatchRequest, WatcherGetWatchRequest, WatcherPutWatchRequest, WatcherStartRequest,
+  WatcherStatsRequest, WatcherStopRequest, XpackInfoRequest, XpackUsageRequest
+}
\ No newline at end of file
diff --git a/api/ResponseTypes.d.ts b/api/ResponseTypes.d.ts
new file mode 100644
index 000000000..d9fa0614e
--- /dev/null
+++ b/api/ResponseTypes.d.ts
@@ -0,0 +1,132 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+interface SearchResponse<TSource = unknown, TAggregations = unknown> {
+  took: number
+  timed_out: boolean
+  _scroll_id?: string
+  _shards: Shards
+  hits: {
+    total: {
+      value: number
+      relation: string
+    }
+    max_score: number
+    hits: Array<{
+      _index: string
+      _type: string
+      _id: string
+      _score: number
+      _source: TSource
+      _version?: number
+      _explanation?: Explanation
+      fields?: Record<string, unknown>
+      highlight?: Record<string, string[]>
+      inner_hits?: Record<string, unknown>
+      matched_queries?: string[]
+      sort?: any[]
+    }>
+  }
+  aggregations?: TAggregations
+}
+
+interface Shards {
+  total: number
+  successful: number
+  failed: number
+  skipped: number
+}
+
+interface Explanation {
+  value: number
+  description: string
+  details: Explanation[]
+}
+
+interface MSearchResponse<TSource = unknown, TAggregations = unknown> {
+  responses: Array<SearchResponse<TSource, TAggregations>>
+}
+
+interface CreateResponse {
+  _shards: Shards
+  _index: string
+  _type: string
+  _id: string
+  _version: number
+  _seq_no: number
+  _primary_term: number
+  result: string
+}
+
+interface IndexResponse extends CreateResponse {}
+
+interface DeleteResponse {
+  _shards: Shards
+  _index: string
+  _type: string
+  _id: string
+  _version: number
+  _seq_no: number
+  _primary_term: number
+  result: string
+}
+
+interface UpdateResponse {
+  _shards: Shards
+  _index: string
+  _type: string
+  _id: string
+  _version: number
+  result: string
+}
+
+interface GetResponse<TSource = unknown> {
+  _index: string
+  _type: string
+  _id: string
+  _version: number
+  _seq_no: number
+  _primary_term: number
+  found: boolean
+  _source: TSource
+}
+
+interface BulkResponse {
+  took: number
+  errors: boolean
+  items: BulkItem[]
+}
+
+type BulkItem =
+  | { index: BulkIndex }
+  | { create: BulkCreate }
+  | { update: BulkUpdate }
+  | { delete: BulkDelete }
+
+interface BulkIndex extends IndexResponse {
+  status: number
+}
+
+interface BulkCreate extends CreateResponse {
+  status: number
+}
+
+interface BulkUpdate extends UpdateResponse {
+  status: number
+}
+
+interface BulkDelete extends DeleteResponse {
+  status: number
+}
+
+export {
+  SearchResponse,
+  MSearchResponse,
+  CreateResponse,
+  IndexResponse,
+  DeleteResponse,
+  UpdateResponse,
+  GetResponse,
+  BulkResponse
+}
\ No newline at end of file
diff --git a/api/kibana.d.ts b/api/kibana.d.ts
index 5125e70aa..1f2c3fad4 100644
--- a/api/kibana.d.ts
+++ b/api/kibana.d.ts
@@ -24,7 +24,8 @@ import {
   TransportRequestPromise,
   Context
 } from '../lib/Transport'
-import * as RequestParams from './requestParams'
+import * as Req from './RequestTypes';
+import * as Res from './ResponseTypes';
 
 // Extend API
 interface ClientExtendsCallbackOptions {
@@ -61,406 +62,406 @@ interface KibanaClient {
   off(event: string | symbol, listener: (...args: any[]) => void): this;
   /* GENERATED */
   asyncSearch: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchSubmit<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchSubmitRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   autoscaling: {
-    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingDeleteAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingDecision, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingGetAutoscalingDecisionRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.Bulk<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.BulkRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   cat: {
-    aliases<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatAliases, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    allocation<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatAllocation, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    count<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatCount, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    fielddata<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatFielddata, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    health<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatHealth, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    help<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatHelp, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    indices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    master<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMaster, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlDatafeeds, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    mlJobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlTrainedModels, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatNodeattrs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    nodes<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatNodes, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatPendingTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    plugins<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatPlugins, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    recovery<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatRecovery, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    repositories<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatRepositories, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    segments<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatSegments, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    shards<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatShards, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    snapshots<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatSnapshots, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    tasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    templates<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatTemplates, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    threadPool<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatThreadPool, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    transforms<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatTransforms, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    aliases<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatAliasesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    allocation<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatAllocationRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    count<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatCountRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    fielddata<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatFielddataRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    health<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatHealthRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    help<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatHelpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    indices<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    master<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMasterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlDatafeedsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlJobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlTrainedModelsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatNodeattrsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    nodes<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatNodesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatPendingTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    plugins<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatPluginsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    recovery<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatRecoveryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repositories<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatRepositoriesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    segments<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatSegmentsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shards<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatShardsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    snapshots<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatSnapshotsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    tasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    templates<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatTemplatesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    threadPool<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatThreadPoolRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    transforms<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatTransformsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   ccr: {
-    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrDeleteAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollow<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    followInfo<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollowInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    followStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollowStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrForgetFollower<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrGetAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPauseAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPauseFollow, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrResumeAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrResumeFollow<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    unfollow<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrUnfollow, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrFollowRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    followInfo<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrFollowInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    followStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrFollowStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrForgetFollowerRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrPauseFollowRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrResumeFollowRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    unfollow<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrUnfollowRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClearScroll<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClearScrollRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   cluster: {
-    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterAllocationExplain<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterDeleteComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterDeleteVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterExistsComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterGetComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterGetSettings, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    health<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterHealth, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPendingTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPostVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPutComponentTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPutSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterRemoteInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterReroute<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    state<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterState, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterAllocationExplainRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterDeleteVotingConfigExclusionsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterExistsComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterGetComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterGetSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    health<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterHealthRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterPendingTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterPostVotingConfigExclusionsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterPutComponentTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterPutSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterRemoteInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterRerouteRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    state<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterStateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Count<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Create<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CountRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CreateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   danglingIndices: {
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   dataFrameTransformDeprecated: {
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Delete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteByQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  deleteScript<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteScript, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DeleteByQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteByQueryRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  deleteScript<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteScriptRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   enrich: {
-    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichDeletePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    executePolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichExecutePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getPolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichGetPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichPutPolicy<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichDeletePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executePolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichExecutePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getPolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichGetPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.EnrichPutPolicyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   eql: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EqlDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EqlGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.EqlSearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.EqlDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.EqlGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.EqlSearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  exists<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Exists, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  existsSource<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ExistsSource, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Explain<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.FieldCaps<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Get, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  getScript<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScript, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScriptContext, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScriptLanguages, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  getSource<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetSource, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  exists<TResponse = Record<string, any>, TContext = Context>(params?: Req.ExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  existsSource<TResponse = Record<string, any>, TContext = Context>(params?: Req.ExistsSourceRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ExplainRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.FieldCapsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  get<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getScript<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptContextRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptLanguagesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getSource<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetSourceRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   graph: {
-    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.GraphExplore<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.GraphExploreRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   ilm: {
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmExplainLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmMoveToStep<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmPutLifecycle<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    removePolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmRemovePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    retry<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmRetry, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    start<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmStart, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stop<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmStop, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmDeleteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmExplainLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IlmMoveToStepRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IlmPutLifecycleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    removePolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmRemovePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    retry<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmRetryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmStartRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmStopRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  index<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Index<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  index<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndexRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   indices: {
-    addBlock<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesAddBlock, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesAnalyze<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClone<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    close<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClose, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesCreate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesCreateDataStream<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDataStreamsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteDataStream, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    exists<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExists, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    existsAlias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    existsType<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsType, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    flush<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesFlush, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    forcemerge<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesForcemerge, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    freeze<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesFreeze, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getAlias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getDataStream<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetDataStream, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetFieldMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetSettings, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetUpgrade, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    open<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesOpen, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutAlias<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutIndexTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutMapping<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    recovery<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesRecovery, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    refresh<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesRefresh, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesReloadSearchAnalyzers, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesResolveIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesRollover<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    segments<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSegments, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    shardStores<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesShardStores, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesShrink<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSimulateTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSplit<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    unfreeze<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUnfreeze, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUpdateAliases<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    upgrade<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUpgrade, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesValidateQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    addBlock<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesAnalyzeRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCloneRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    close<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesCloseRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCreateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCreateDataStreamRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsAlias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsType<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsTypeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    flush<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesFlushRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forcemerge<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesForcemergeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    freeze<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesFreezeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAlias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDataStream<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetFieldMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetUpgradeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    open<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesOpenRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutAliasRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutIndexTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutMappingRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    recovery<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesRecoveryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    refresh<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesRefreshRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesRolloverRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    segments<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesSegmentsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shardStores<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesShardStoresRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesShrinkRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSimulateTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSplitRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    unfreeze<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesUnfreezeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesUpdateAliasesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    upgrade<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesUpgradeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesValidateQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Info, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  info<TResponse = Record<string, any>, TContext = Context>(params?: Req.InfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   ingest: {
-    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getPipeline<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestGetPipeline, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    processorGrok<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestProcessorGrok, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IngestPutPipeline<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IngestSimulate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestDeletePipelineRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getPipeline<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestGetPipelineRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    processorGrok<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestProcessorGrokRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IngestPutPipelineRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IngestSimulateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   license: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGetBasicStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGetTrialStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePost<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePostStartBasic, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePostStartTrial, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetBasicStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetTrialStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.LicensePostRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicensePostStartBasicRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicensePostStartTrialRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Mget<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MgetRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   migration: {
-    deprecations<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MigrationDeprecations, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deprecations<TResponse = Record<string, any>, TContext = Context>(params?: Req.MigrationDeprecationsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   ml: {
-    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlCloseJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendar, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendarEvent, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendarJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteExpiredData<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteFilter, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteForecast, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteTrainedModel, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlEstimateModelMemory<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlEvaluateDataFrame<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MlFindFileStructure<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlFlushJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    forecast<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlForecast, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetBuckets<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCalendars<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCategories<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalyticsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDatafeedStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDatafeeds, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getFilters<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetFilters, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetInfluencers<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getJobStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetJobStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetModelSnapshots<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetOverallBuckets<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetRecords<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetTrainedModels, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetTrainedModelsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    openJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlOpenJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPostCalendarEvents<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPostData<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlPreviewDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutCalendar<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutCalendarJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutFilter<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutTrainedModel<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlRevertModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlSetUpgradeMode, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStartDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlStopDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateFilter<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlValidate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlValidateDetector<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlCloseJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarEventRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlDeleteExpiredDataRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteFilterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteForecastRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlEstimateModelMemoryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlEvaluateDataFrameRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MlFindFileStructureRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlFlushJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forecast<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlForecastRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetBucketsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetCalendarEventsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetCalendarsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetCategoriesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDataFrameAnalyticsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDatafeedStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDatafeedsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getFilters<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetFiltersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetInfluencersRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getJobStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetJobStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetModelSnapshotsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetOverallBucketsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetRecordsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetTrainedModelsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetTrainedModelsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    openJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlOpenJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPostCalendarEventsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPostDataRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlPreviewDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutCalendarRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlPutCalendarJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutFilterRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutTrainedModelRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlRevertModelSnapshotRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlSetUpgradeModeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStartDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlStopDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateFilterRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateModelSnapshotRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlValidateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlValidateDetectorRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   monitoring: {
-    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MonitoringBulk<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MonitoringBulkRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.Msearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MsearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Mtermvectors<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MsearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MsearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MtermvectorsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   nodes: {
-    hotThreads<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesHotThreads, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.NodesReloadSecureSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    usage<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesUsage, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    hotThreads<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesHotThreadsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.NodesReloadSecureSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    usage<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesUsageRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  ping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Ping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.PutScript<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RankEval<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Reindex<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ReindexRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RenderSearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  ping<TResponse = Record<string, any>, TContext = Context>(params?: Req.PingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.PutScriptRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RankEvalRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ReindexRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.ReindexRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RenderSearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   rollup: {
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupDeleteJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetRollupCaps, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetRollupIndexCaps, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RollupPutJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RollupRollupSearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    startJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupStartJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stopJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupStopJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupDeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetRollupCapsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetRollupIndexCapsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RollupPutJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RollupRollupSearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupStartJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupStopJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ScriptsPainlessExecute<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Scroll<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Search<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  searchShards<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchShards, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ScriptsPainlessExecuteRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ScrollRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  searchShards<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchShardsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   searchableSnapshots: {
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsMount<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsRepositoryStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsMountRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsRepositoryStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   security: {
-    authenticate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityAuthenticate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityChangePassword<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedRealms, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedRoles, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityCreateApiKey<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeletePrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteRole<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteRole, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteRoleMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    disableUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDisableUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    enableUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityEnableUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getApiKey<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetApiKey, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetBuiltinPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getRole<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetRole, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetRoleMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetToken<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetUserPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityHasPrivileges<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityInvalidateApiKey<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityInvalidateToken<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutPrivileges<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutRole<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutRoleMapping<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutUser<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    authenticate<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityAuthenticateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityChangePasswordRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedRolesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityCreateApiKeyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeletePrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteRole<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    disableUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDisableUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    enableUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityEnableUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getApiKey<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetApiKeyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetBuiltinPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRole<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityGetTokenRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetUserPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityHasPrivilegesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityInvalidateTokenRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutPrivilegesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutRoleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutRoleMappingRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutUserRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   slm: {
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmExecuteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    executeRetention<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmExecuteRetention, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SlmPutLifecycle<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    start<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmStart, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stop<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmStop, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmDeleteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmExecuteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executeRetention<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmExecuteRetentionRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SlmPutLifecycleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmStartRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmStopRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   snapshot: {
-    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCleanupRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCreate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCreateRepository<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotDeleteRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotGetRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotRestore<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotVerifyRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotCleanupRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotCreateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotCreateRepositoryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotDeleteRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotGetRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotRestoreRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    status<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotVerifyRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   sql: {
-    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlClearCursor<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlTranslate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlClearCursorRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlTranslateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   ssl: {
-    certificates<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SslCertificates, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    certificates<TResponse = Record<string, any>, TContext = Context>(params?: Req.SslCertificatesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   tasks: {
-    cancel<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TasksCancel, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TasksGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    list<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TasksList, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cancel<TResponse = Record<string, any>, TContext = Context>(params?: Req.TasksCancelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.TasksGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    list<TResponse = Record<string, any>, TContext = Context>(params?: Req.TasksListRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Termvectors<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TermvectorsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   transform: {
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
-  update<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Update<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.UpdateByQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.UpdateByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  update<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.UpdateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.UpdateByQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.UpdateByQueryRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   watcher: {
-    ackWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherAckWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    activateWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherActivateWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherDeactivateWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherDeleteWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherExecuteWatch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    getWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherGetWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherPutWatch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    start<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherStart, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    stop<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherStop, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ackWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherAckWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    activateWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherActivateWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherDeactivateWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherDeleteWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.WatcherExecuteWatchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherGetWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.WatcherPutWatchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherStartRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherStopRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   xpack: {
-    info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.XpackInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-    usage<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.XpackUsage, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params?: Req.XpackInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    usage<TResponse = Record<string, any>, TContext = Context>(params?: Req.XpackUsageRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   }
   /* /GENERATED */
 }
diff --git a/docs/typescript.asciidoc b/docs/typescript.asciidoc
index 2400b684e..775a0c31d 100644
--- a/docs/typescript.asciidoc
+++ b/docs/typescript.asciidoc
@@ -147,3 +147,63 @@ async function run () {
 
 run().catch(console.log)
 ----
+
+=== Response body definitions
+
+Currently, there is no support for all the response definitions, the client offers only a small subset to help the users with the most commonly used APIs.
+
+* `Index`
+* `Create`
+* `Update`
+* `Delete`
+* `Search`
+* `MSearch`
+* `Bulk`
+
+_At the moment, we are not planning on expanding more the types offered out of the box since we are studying a more structured approach that will allow us to generate all the response type definitions automatically._
+
+You can access the response type definitions via the `ResponseParams`.
+Every API that contains a `_source` object accepts a https://www.typescriptlang.org/docs/handbook/generics.html[generics] which represents the type of the `_source` object, if you don't configure anything, it will default to `any`.
+
+The example you saw above can now be rewritten as follows:
+[source,ts]
+----
+import {
+  Client,
+  RequestParams,
+  ResponseParams,
+  ApiResponse,
+} from '@elastic/elasticsearch'
+
+const client = new Client({ node: 'http://localhost:9200' })
+
+// Define the type of the body for the Search request
+interface SearchBody {
+  query: {
+    match: { foo: string }
+  }
+}
+
+// Define the interface of the source object
+interface Source {
+  foo: string
+}
+
+async function run (): Promise<void> {
+  // Define the search parameters
+  const searchParams: RequestParams.Search<SearchBody> = {
+    index: 'test',
+    body: {
+      query: {
+        match: { foo: 'bar' }
+      }
+    }
+  }
+
+  // Craft the final type definition
+  const response: ApiResponse<ResponseParams.Search<Source>> = await client.search(searchParams)
+  console.log(response.body)
+}
+
+run().catch(console.log)
+----
diff --git a/index.d.ts b/index.d.ts
index 14161b26c..e0af0615d 100644
--- a/index.d.ts
+++ b/index.d.ts
@@ -32,7 +32,8 @@ import {
 } from './lib/pool';
 import Serializer from './lib/Serializer';
 import Helpers from './lib/Helpers';
-import * as RequestParams from './api/requestParams';
+import * as Req from './api/RequestTypes';
+import * as Res from './api/ResponseTypes';
 import * as errors from './lib/errors';
 
 declare type callbackFn<TResponse, TContext> = (err: ApiError, result: ApiResponse<TResponse, TContext>) => void;
@@ -124,2514 +125,2514 @@ declare class Client {
   off(event: string | symbol, listener: (...args: any[]) => void): this;
   /* GENERATED */
   async_search: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchDelete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchDelete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchDeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchDeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchSubmit<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchSubmitRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchSubmit<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchSubmit<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AsyncSearchSubmitRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AsyncSearchSubmitRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   asyncSearch: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchDelete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchDelete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchDeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchDeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.AsyncSearchSubmit<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.AsyncSearchGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.AsyncSearchSubmitRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchSubmit<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AsyncSearchSubmit<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AsyncSearchSubmitRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    submit<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AsyncSearchSubmitRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   autoscaling: {
-    delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingDeleteAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingDeleteAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingDeleteAutoscalingPolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingDeleteAutoscalingPolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingDeleteAutoscalingPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingDeleteAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingDecision, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingDeleteAutoscalingPolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingDeleteAutoscalingPolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingGetAutoscalingDecisionRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingDecision, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingDecision, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingDecision, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingDecisionRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_autoscaling_decision<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingDecisionRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingGetAutoscalingDecisionRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingDecision, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingDecision, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingDecisionRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAutoscalingDecision<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingDecisionRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingGetAutoscalingPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingPolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_autoscaling_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingPolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.AutoscalingGetAutoscalingPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingGetAutoscalingPolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingPolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAutoscalingPolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.AutoscalingGetAutoscalingPolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_autoscaling_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.AutoscalingPutAutoscalingPolicy<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAutoscalingPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.AutoscalingPutAutoscalingPolicyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.Bulk<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.Bulk<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.Bulk<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  bulk<TResponse = Res.BulkResponse, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.BulkRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  bulk<TResponse = Res.BulkResponse, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  bulk<TResponse = Res.BulkResponse, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.BulkRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  bulk<TResponse = Res.BulkResponse, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.BulkRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   cat: {
-    aliases<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatAliases, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    aliases<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatAliasesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     aliases<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    aliases<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatAliases, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    aliases<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatAliases, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocation<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatAllocation, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    aliases<TResponse = Record<string, any>, TContext = Context>(params: Req.CatAliasesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    aliases<TResponse = Record<string, any>, TContext = Context>(params: Req.CatAliasesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    allocation<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatAllocationRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     allocation<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocation<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatAllocation, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocation<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatAllocation, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    count<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatCount, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    allocation<TResponse = Record<string, any>, TContext = Context>(params: Req.CatAllocationRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    allocation<TResponse = Record<string, any>, TContext = Context>(params: Req.CatAllocationRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    count<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatCountRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     count<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    count<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatCount, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    count<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatCount, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    fielddata<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatFielddata, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    count<TResponse = Record<string, any>, TContext = Context>(params: Req.CatCountRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    count<TResponse = Record<string, any>, TContext = Context>(params: Req.CatCountRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    fielddata<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatFielddataRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     fielddata<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    fielddata<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatFielddata, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    fielddata<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatFielddata, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    health<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatHealth, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    fielddata<TResponse = Record<string, any>, TContext = Context>(params: Req.CatFielddataRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    fielddata<TResponse = Record<string, any>, TContext = Context>(params: Req.CatFielddataRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    health<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatHealthRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     health<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    health<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatHealth, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    health<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatHealth, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    help<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatHelp, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    health<TResponse = Record<string, any>, TContext = Context>(params: Req.CatHealthRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    health<TResponse = Record<string, any>, TContext = Context>(params: Req.CatHealthRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    help<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatHelpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     help<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    help<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatHelp, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    help<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatHelp, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    indices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    help<TResponse = Record<string, any>, TContext = Context>(params: Req.CatHelpRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    help<TResponse = Record<string, any>, TContext = Context>(params: Req.CatHelpRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    indices<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     indices<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    indices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatIndices, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    indices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatIndices, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    master<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMaster, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    indices<TResponse = Record<string, any>, TContext = Context>(params: Req.CatIndicesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    indices<TResponse = Record<string, any>, TContext = Context>(params: Req.CatIndicesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    master<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMasterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     master<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    master<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMaster, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    master<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMaster, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    master<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMasterRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    master<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMasterRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDataFrameAnalyticsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDataFrameAnalyticsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlDatafeeds, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDataFrameAnalyticsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDataFrameAnalyticsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlDatafeedsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDatafeeds, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDatafeeds, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlDatafeeds, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDatafeedsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDatafeedsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlDatafeedsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDatafeeds, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlDatafeeds, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_jobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDatafeedsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlDatafeedsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_jobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     ml_jobs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_jobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlJobs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_jobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlJobs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlJobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ml_jobs<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlJobsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_jobs<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlJobsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlJobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     mlJobs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlJobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlJobs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlJobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlJobs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_trained_models<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlTrainedModels, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlJobs<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlJobsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlJobs<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlJobsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_trained_models<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlTrainedModelsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     ml_trained_models<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_trained_models<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlTrainedModels, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ml_trained_models<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlTrainedModels, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatMlTrainedModels, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ml_trained_models<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlTrainedModelsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ml_trained_models<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlTrainedModelsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatMlTrainedModelsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlTrainedModels, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatMlTrainedModels, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatNodeattrs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlTrainedModelsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mlTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: Req.CatMlTrainedModelsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatNodeattrsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     nodeattrs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatNodeattrs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatNodeattrs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    nodes<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatNodes, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params: Req.CatNodeattrsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    nodeattrs<TResponse = Record<string, any>, TContext = Context>(params: Req.CatNodeattrsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    nodes<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatNodesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     nodes<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    nodes<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatNodes, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    nodes<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatNodes, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatPendingTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    nodes<TResponse = Record<string, any>, TContext = Context>(params: Req.CatNodesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    nodes<TResponse = Record<string, any>, TContext = Context>(params: Req.CatNodesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatPendingTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pending_tasks<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatPendingTasks, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatPendingTasks, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatPendingTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: Req.CatPendingTasksRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: Req.CatPendingTasksRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatPendingTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pendingTasks<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatPendingTasks, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatPendingTasks, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    plugins<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatPlugins, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: Req.CatPendingTasksRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: Req.CatPendingTasksRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    plugins<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatPluginsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     plugins<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    plugins<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatPlugins, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    plugins<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatPlugins, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    recovery<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatRecovery, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    plugins<TResponse = Record<string, any>, TContext = Context>(params: Req.CatPluginsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    plugins<TResponse = Record<string, any>, TContext = Context>(params: Req.CatPluginsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    recovery<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatRecoveryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     recovery<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    recovery<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatRecovery, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    recovery<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatRecovery, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositories<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatRepositories, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    recovery<TResponse = Record<string, any>, TContext = Context>(params: Req.CatRecoveryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    recovery<TResponse = Record<string, any>, TContext = Context>(params: Req.CatRecoveryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositories<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatRepositoriesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     repositories<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositories<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatRepositories, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositories<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatRepositories, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    segments<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatSegments, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repositories<TResponse = Record<string, any>, TContext = Context>(params: Req.CatRepositoriesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositories<TResponse = Record<string, any>, TContext = Context>(params: Req.CatRepositoriesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    segments<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatSegmentsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     segments<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    segments<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatSegments, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    segments<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatSegments, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shards<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatShards, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    segments<TResponse = Record<string, any>, TContext = Context>(params: Req.CatSegmentsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    segments<TResponse = Record<string, any>, TContext = Context>(params: Req.CatSegmentsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shards<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatShardsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     shards<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shards<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatShards, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shards<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatShards, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    snapshots<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatSnapshots, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shards<TResponse = Record<string, any>, TContext = Context>(params: Req.CatShardsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shards<TResponse = Record<string, any>, TContext = Context>(params: Req.CatShardsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    snapshots<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatSnapshotsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     snapshots<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    snapshots<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatSnapshots, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    snapshots<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatSnapshots, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    tasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    snapshots<TResponse = Record<string, any>, TContext = Context>(params: Req.CatSnapshotsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    snapshots<TResponse = Record<string, any>, TContext = Context>(params: Req.CatSnapshotsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    tasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     tasks<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    tasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatTasks, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    tasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatTasks, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    templates<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatTemplates, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    tasks<TResponse = Record<string, any>, TContext = Context>(params: Req.CatTasksRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    tasks<TResponse = Record<string, any>, TContext = Context>(params: Req.CatTasksRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    templates<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatTemplatesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     templates<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    templates<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatTemplates, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    templates<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatTemplates, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    thread_pool<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatThreadPool, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    templates<TResponse = Record<string, any>, TContext = Context>(params: Req.CatTemplatesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    templates<TResponse = Record<string, any>, TContext = Context>(params: Req.CatTemplatesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    thread_pool<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatThreadPoolRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     thread_pool<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    thread_pool<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatThreadPool, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    thread_pool<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatThreadPool, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    threadPool<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatThreadPool, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    thread_pool<TResponse = Record<string, any>, TContext = Context>(params: Req.CatThreadPoolRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    thread_pool<TResponse = Record<string, any>, TContext = Context>(params: Req.CatThreadPoolRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    threadPool<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatThreadPoolRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     threadPool<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    threadPool<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatThreadPool, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    threadPool<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatThreadPool, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    transforms<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CatTransforms, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    threadPool<TResponse = Record<string, any>, TContext = Context>(params: Req.CatThreadPoolRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    threadPool<TResponse = Record<string, any>, TContext = Context>(params: Req.CatThreadPoolRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    transforms<TResponse = Record<string, any>, TContext = Context>(params?: Req.CatTransformsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     transforms<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    transforms<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatTransforms, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    transforms<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CatTransforms, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    transforms<TResponse = Record<string, any>, TContext = Context>(params: Req.CatTransformsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    transforms<TResponse = Record<string, any>, TContext = Context>(params: Req.CatTransformsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   ccr: {
-    delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrDeleteAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrDeleteAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrDeleteAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrDeleteAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrDeleteAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrDeleteAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollow<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrDeleteAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrDeleteAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrFollowRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollow<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollow<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow_info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollowInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrFollowRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrFollowRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    follow_info<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrFollowInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     follow_info<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow_info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow_info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    followInfo<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollowInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    follow_info<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    follow_info<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    followInfo<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrFollowInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     followInfo<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    followInfo<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    followInfo<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollowStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    followInfo<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    followInfo<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    follow_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrFollowStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     follow_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    follow_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    followStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrFollowStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    follow_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    follow_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    followStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrFollowStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     followStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    followStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    followStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrFollowStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrForgetFollower<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    followStats<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    followStats<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrFollowStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrForgetFollowerRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrForgetFollower<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrForgetFollower<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrForgetFollower<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrForgetFollowerRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forget_follower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrForgetFollowerRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrForgetFollowerRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrForgetFollower<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrForgetFollower<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrGetAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrForgetFollowerRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forgetFollower<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrForgetFollowerRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrGetAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrGetAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrGetAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrGetAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrGetAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPauseAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrGetAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrGetAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPauseAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pause_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrPauseAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pause_follow<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPauseFollow, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pauseAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pause_follow<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrPauseFollowRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pause_follow<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pause_follow<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseFollow, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pause_follow<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseFollow, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPauseFollow, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pause_follow<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseFollowRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pause_follow<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseFollowRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrPauseFollowRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pauseFollow<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseFollow, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrPauseFollow, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseFollowRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pauseFollow<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrPauseFollowRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_auto_follow_pattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrPutAutoFollowPattern<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrResumeAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAutoFollowPattern<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrPutAutoFollowPatternRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrResumeAutoFollowPattern, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrResumeAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resume_auto_follow_pattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrResumeAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrResumeAutoFollowPatternRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeAutoFollowPattern, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrResumeFollow<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrResumeAutoFollowPatternRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resumeAutoFollowPattern<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrResumeAutoFollowPatternRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrResumeFollowRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeFollow<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeFollow<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.CcrResumeFollow<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrResumeFollowRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resume_follow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrResumeFollowRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CcrResumeFollowRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeFollow<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.CcrResumeFollow<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrResumeFollowRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resumeFollow<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CcrResumeFollowRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    unfollow<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.CcrUnfollow, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    unfollow<TResponse = Record<string, any>, TContext = Context>(params?: Req.CcrUnfollowRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     unfollow<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    unfollow<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrUnfollow, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    unfollow<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.CcrUnfollow, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    unfollow<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrUnfollowRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    unfollow<TResponse = Record<string, any>, TContext = Context>(params: Req.CcrUnfollowRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClearScroll<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClearScrollRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClearScroll<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClearScroll<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClearScroll<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClearScrollRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  clear_scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClearScrollRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClearScrollRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClearScroll<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClearScroll<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClearScrollRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  clearScroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClearScrollRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   cluster: {
-    allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterAllocationExplain<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterAllocationExplainRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterAllocationExplain<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterAllocationExplain<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterAllocationExplain<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterAllocationExplainRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    allocation_explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterAllocationExplainRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterAllocationExplainRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterAllocationExplain<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterAllocationExplain<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_component_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterDeleteComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterAllocationExplainRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    allocationExplain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterAllocationExplainRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_component_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_component_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_component_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_component_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterDeleteComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_component_template<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteComponentTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_component_template<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterDeleteComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteComponentTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterDeleteVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteComponentTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterDeleteVotingConfigExclusionsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterDeleteVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteVotingConfigExclusionsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteVotingConfigExclusionsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterDeleteVotingConfigExclusionsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterDeleteVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_component_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterExistsComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteVotingConfigExclusionsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterDeleteVotingConfigExclusionsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_component_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterExistsComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     exists_component_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_component_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterExistsComponentTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_component_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterExistsComponentTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterExistsComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists_component_template<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterExistsComponentTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_component_template<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterExistsComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterExistsComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterExistsComponentTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterExistsComponentTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_component_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterGetComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterExistsComponentTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterExistsComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_component_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterGetComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_component_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_component_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_component_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterGetComponentTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_component_template<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetComponentTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_component_template<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterGetComponentTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetComponentTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_settings<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterGetSettings, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetComponentTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getComponentTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetComponentTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_settings<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterGetSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_settings<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_settings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetSettings, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_settings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetSettings, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterGetSettings, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_settings<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetSettingsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_settings<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetSettingsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterGetSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getSettings<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetSettings, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterGetSettings, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    health<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterHealth, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetSettingsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterGetSettingsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    health<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterHealthRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     health<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    health<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterHealth, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    health<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterHealth, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPendingTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    health<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterHealthRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    health<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterHealthRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterPendingTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pending_tasks<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPendingTasks, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPendingTasks, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPendingTasks, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPendingTasksRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pending_tasks<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPendingTasksRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterPendingTasksRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     pendingTasks<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPendingTasks, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPendingTasks, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPostVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPendingTasksRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    pendingTasks<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPendingTasksRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterPostVotingConfigExclusionsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPostVotingConfigExclusions, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPostVotingConfigExclusionsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_voting_config_exclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPostVotingConfigExclusionsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterPostVotingConfigExclusionsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPostVotingConfigExclusions, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPutComponentTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPostVotingConfigExclusionsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postVotingConfigExclusions<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterPostVotingConfigExclusionsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterPutComponentTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPutComponentTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutComponentTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_component_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutComponentTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterPutComponentTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutComponentTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPutSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutComponentTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putComponentTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutComponentTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterPutSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutSettings<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutSettings<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterPutSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutSettingsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutSettingsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterPutSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutSettings<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterPutSettings<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remote_info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterRemoteInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutSettingsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterPutSettingsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    remote_info<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterRemoteInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     remote_info<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remote_info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterRemoteInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remote_info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterRemoteInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterRemoteInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    remote_info<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterRemoteInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    remote_info<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterRemoteInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterRemoteInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     remoteInfo<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterRemoteInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterRemoteInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterReroute<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterRemoteInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    remoteInfo<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterRemoteInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ClusterRerouteRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterReroute<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ClusterReroute<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    state<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterState, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterRerouteRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reroute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ClusterRerouteRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    state<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterStateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     state<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    state<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterState, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    state<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterState, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ClusterStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    state<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterStateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    state<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterStateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.ClusterStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ClusterStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.ClusterStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Count<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CountRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Count<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Count<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Create<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Create<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Create<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CountRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  count<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CountRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  create<TResponse = Res.CreateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.CreateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  create<TResponse = Res.CreateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  create<TResponse = Res.CreateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CreateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  create<TResponse = Res.CreateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.CreateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   dangling_indices: {
-    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     import_dangling_index<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   danglingIndices: {
-    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesDeleteDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesDeleteDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesDeleteDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesDeleteDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     import_dangling_index<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesImportDanglingIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    import_dangling_index<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesImportDanglingIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesImportDanglingIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    importDanglingIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesImportDanglingIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DanglingIndicesListDanglingIndices, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list_dangling_indices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params?: Req.DanglingIndicesListDanglingIndicesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DanglingIndicesListDanglingIndices, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    listDanglingIndices<TResponse = Record<string, any>, TContext = Context>(params: Req.DanglingIndicesListDanglingIndicesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   data_frame_transform_deprecated: {
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_transform_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTransformStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     startTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stopTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   dataFrameTransformDeprecated: {
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedDeleteTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedDeleteTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_transform_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTransformStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedGetTransformStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedGetTransformStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPreviewTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPreviewTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedPutTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedPutTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     startTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStartTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStartTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stopTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedStopTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedStopTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DataFrameTransformDeprecatedUpdateTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DataFrameTransformDeprecatedUpdateTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Delete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Delete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Delete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteByQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  delete<TResponse = Res.DeleteResponse, TContext = Context>(params?: Req.DeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  delete<TResponse = Res.DeleteResponse, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete<TResponse = Res.DeleteResponse, TContext = Context>(params: Req.DeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete<TResponse = Res.DeleteResponse, TContext = Context>(params: Req.DeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DeleteByQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteByQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.DeleteByQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteByQueryRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRethrottleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRethrottleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteByQueryRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_script<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteScript, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRethrottleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteByQueryRethrottleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete_script<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteScriptRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   delete_script<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_script<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteScript, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  delete_script<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteScript, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteScript<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.DeleteScript, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  delete_script<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteScriptRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  delete_script<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteScriptRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteScript<TResponse = Record<string, any>, TContext = Context>(params?: Req.DeleteScriptRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   deleteScript<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteScript<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteScript, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  deleteScript<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.DeleteScript, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteScript<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteScriptRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  deleteScript<TResponse = Record<string, any>, TContext = Context>(params: Req.DeleteScriptRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   enrich: {
-    delete_policy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichDeletePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_policy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichDeletePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_policy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichDeletePolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichDeletePolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichDeletePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichDeletePolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichDeletePolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichDeletePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deletePolicy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichDeletePolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichDeletePolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_policy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichExecutePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichDeletePolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deletePolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichDeletePolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_policy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichExecutePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     execute_policy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichExecutePolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichExecutePolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executePolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichExecutePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    execute_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichExecutePolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichExecutePolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executePolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichExecutePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     executePolicy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executePolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichExecutePolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executePolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichExecutePolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_policy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichGetPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executePolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichExecutePolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executePolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichExecutePolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_policy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichGetPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_policy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichGetPolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichGetPolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichGetPolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichGetPolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichGetPolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getPolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichGetPolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getPolicy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichGetPolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichGetPolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichPutPolicy<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getPolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichGetPolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getPolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichGetPolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.EnrichPutPolicyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.EnrichPutPolicy<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.EnrichPutPolicy<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichPutPolicy<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.EnrichPutPolicyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_policy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.EnrichPutPolicyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.EnrichPutPolicyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.EnrichPutPolicy<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.EnrichPutPolicy<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EnrichStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.EnrichPutPolicyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putPolicy<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.EnrichPutPolicyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.EnrichStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EnrichStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.EnrichStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   eql: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EqlDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.EqlDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EqlDelete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EqlDelete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.EqlGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.EqlDeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.EqlDeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.EqlGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EqlGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.EqlGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.EqlSearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.EqlGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.EqlGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.EqlSearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.EqlSearch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.EqlSearch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.EqlSearchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.EqlSearchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  exists<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Exists, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  exists<TResponse = Record<string, any>, TContext = Context>(params?: Req.ExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   exists<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  exists<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Exists, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  exists<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Exists, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  exists_source<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ExistsSource, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  exists<TResponse = Record<string, any>, TContext = Context>(params: Req.ExistsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  exists<TResponse = Record<string, any>, TContext = Context>(params: Req.ExistsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  exists_source<TResponse = Record<string, any>, TContext = Context>(params?: Req.ExistsSourceRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   exists_source<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  exists_source<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ExistsSource, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  exists_source<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ExistsSource, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  existsSource<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ExistsSource, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  exists_source<TResponse = Record<string, any>, TContext = Context>(params: Req.ExistsSourceRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  exists_source<TResponse = Record<string, any>, TContext = Context>(params: Req.ExistsSourceRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  existsSource<TResponse = Record<string, any>, TContext = Context>(params?: Req.ExistsSourceRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   existsSource<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  existsSource<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ExistsSource, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  existsSource<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ExistsSource, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Explain<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  existsSource<TResponse = Record<string, any>, TContext = Context>(params: Req.ExistsSourceRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  existsSource<TResponse = Record<string, any>, TContext = Context>(params: Req.ExistsSourceRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ExplainRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Explain<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Explain<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.FieldCaps<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ExplainRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  explain<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ExplainRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.FieldCapsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.FieldCaps<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.FieldCaps<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.FieldCaps<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.FieldCapsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  field_caps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.FieldCapsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.FieldCapsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.FieldCaps<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.FieldCaps<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Get, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Get, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Get, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScript, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.FieldCapsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  fieldCaps<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.FieldCapsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get<TResponse = Res.GetResponse, TContext = Context>(params?: Req.GetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  get<TResponse = Res.GetResponse, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get<TResponse = Res.GetResponse, TContext = Context>(params: Req.GetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get<TResponse = Res.GetResponse, TContext = Context>(params: Req.GetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_script<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   get_script<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScript, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScript, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScript<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScript, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  get_script<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_script<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getScript<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   getScript<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScript<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScript, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScript<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScript, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script_context<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScriptContext, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getScript<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getScript<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_script_context<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptContextRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   get_script_context<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script_context<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptContext, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script_context<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptContext, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScriptContext, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  get_script_context<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptContextRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_script_context<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptContextRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptContextRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   getScriptContext<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptContext, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptContext, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script_languages<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScriptLanguages, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptContextRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getScriptContext<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptContextRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_script_languages<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptLanguagesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   get_script_languages<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script_languages<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptLanguages, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_script_languages<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptLanguages, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetScriptLanguages, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  get_script_languages<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptLanguagesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_script_languages<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptLanguagesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetScriptLanguagesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptLanguages, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetScriptLanguages, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_source<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetSource, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptLanguagesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getScriptLanguages<TResponse = Record<string, any>, TContext = Context>(params: Req.GetScriptLanguagesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_source<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetSourceRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   get_source<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_source<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetSource, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  get_source<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetSource, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getSource<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.GetSource, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  get_source<TResponse = Record<string, any>, TContext = Context>(params: Req.GetSourceRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  get_source<TResponse = Record<string, any>, TContext = Context>(params: Req.GetSourceRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getSource<TResponse = Record<string, any>, TContext = Context>(params?: Req.GetSourceRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   getSource<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getSource<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetSource, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  getSource<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.GetSource, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getSource<TResponse = Record<string, any>, TContext = Context>(params: Req.GetSourceRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  getSource<TResponse = Record<string, any>, TContext = Context>(params: Req.GetSourceRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   graph: {
-    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.GraphExplore<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.GraphExploreRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.GraphExplore<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.GraphExplore<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.GraphExploreRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.GraphExploreRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   ilm: {
-    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmDeleteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmDeleteLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmDeleteLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmDeleteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmExplainLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmDeleteLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmDeleteLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmExplainLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmExplainLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmExplainLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmExplainLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmExplainLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explain_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmExplainLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmExplainLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     explainLifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmExplainLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmExplainLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmExplainLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explainLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmExplainLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_lifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getLifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_status<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_status<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_status<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_status<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getStatus<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmGetStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmMoveToStep<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmGetStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IlmMoveToStepRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMoveToStep<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMoveToStep<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmMoveToStep<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmMoveToStepRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    move_to_step<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmMoveToStepRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IlmMoveToStepRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMoveToStep<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmMoveToStep<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmPutLifecycle<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmMoveToStepRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    moveToStep<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmMoveToStepRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IlmPutLifecycleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmPutLifecycle<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmPutLifecycle<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IlmPutLifecycle<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmPutLifecycleRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmPutLifecycleRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IlmPutLifecycleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmPutLifecycle<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IlmPutLifecycle<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remove_policy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmRemovePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmPutLifecycleRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IlmPutLifecycleRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    remove_policy<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmRemovePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     remove_policy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remove_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmRemovePolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    remove_policy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmRemovePolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    removePolicy<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmRemovePolicy, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    remove_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmRemovePolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    remove_policy<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmRemovePolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    removePolicy<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmRemovePolicyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     removePolicy<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    removePolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmRemovePolicy, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    removePolicy<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmRemovePolicy, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    retry<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmRetry, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    removePolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmRemovePolicyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    removePolicy<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmRemovePolicyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    retry<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmRetryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     retry<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    retry<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmRetry, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    retry<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmRetry, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmStart, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    retry<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmRetryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    retry<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmRetryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmStartRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmStart, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmStart, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IlmStop, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmStartRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmStartRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params?: Req.IlmStopRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmStop, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IlmStop, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmStopRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params: Req.IlmStopRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  index<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Index<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  index<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  index<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Index<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  index<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Index<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  index<TResponse = Res.IndexResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndexRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  index<TResponse = Res.IndexResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  index<TResponse = Res.IndexResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndexRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  index<TResponse = Res.IndexResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndexRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   indices: {
-    add_block<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesAddBlock, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    add_block<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     add_block<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    add_block<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesAddBlock, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    add_block<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesAddBlock, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    addBlock<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesAddBlock, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    add_block<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesAddBlockRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    add_block<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesAddBlockRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    addBlock<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesAddBlockRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     addBlock<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    addBlock<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesAddBlock, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    addBlock<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesAddBlock, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesAnalyze<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    addBlock<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesAddBlockRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    addBlock<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesAddBlockRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesAnalyzeRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesAnalyze<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesAnalyze<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesAnalyzeRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    analyze<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesAnalyzeRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cache<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClearCache, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClearCache, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesClearCacheRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesClearCacheRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCache<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClearCache, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClearCache, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClone<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesClearCacheRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesClearCacheRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCloneRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClone<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClone<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    close<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesClose, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCloneRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clone<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCloneRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    close<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesCloseRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     close<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    close<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClose, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    close<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesClose, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesCreate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    close<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesCloseRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    close<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesCloseRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCreateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesCreate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesCreate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesCreateDataStream<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCreateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCreateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCreateDataStreamRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesCreateDataStream<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesCreateDataStream<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesCreateDataStream<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCreateDataStreamRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create_data_stream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCreateDataStreamRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesCreateDataStreamRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesCreateDataStream<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesCreateDataStream<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    data_streams_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDataStreamsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCreateDataStreamRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    createDataStream<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesCreateDataStreamRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    data_streams_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     data_streams_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    data_streams_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    data_streams_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDataStreamsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    data_streams_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDataStreamsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    data_streams_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDataStreamsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDataStreamsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDataStreamsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDataStreamsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    dataStreamsStats<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDataStreamsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDelete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDelete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_alias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_alias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_alias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_alias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_alias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_alias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteAliasRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_alias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteAliasRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteAlias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_data_stream<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteDataStream, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteAliasRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteAlias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteAliasRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_data_stream<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_data_stream<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_data_stream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_data_stream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteDataStream, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_data_stream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteDataStreamRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_data_stream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteDataStreamRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteDataStream<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteDataStream, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_index_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteDataStreamRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDataStream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteDataStreamRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_index_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_index_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_index_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_index_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_index_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteIndexTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_index_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteIndexTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteIndexTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteIndexTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteIndexTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesDeleteTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesDeleteTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesDeleteTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExists, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesDeleteTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     exists<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExists, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExists, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_alias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_alias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     exists_alias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_alias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_alias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsAlias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists_alias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsAliasRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_alias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsAliasRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsAlias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     existsAlias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_index_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsAlias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsAliasRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsAlias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsAliasRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_index_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     exists_index_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_index_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsIndexTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_index_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsIndexTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists_index_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsIndexTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_index_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsIndexTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsIndexTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsIndexTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsIndexTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsIndexTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     exists_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     existsTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_type<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsType, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_type<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsTypeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     exists_type<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_type<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsType, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    exists_type<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsType, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsType<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesExistsType, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    exists_type<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTypeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    exists_type<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTypeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsType<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesExistsTypeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     existsType<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsType<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsType, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    existsType<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesExistsType, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flush<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesFlush, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    existsType<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTypeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    existsType<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesExistsTypeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    flush<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesFlushRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     flush<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flush<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesFlush, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flush<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesFlush, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forcemerge<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesForcemerge, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    flush<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesFlushRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    flush<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesFlushRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forcemerge<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesForcemergeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     forcemerge<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forcemerge<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesForcemerge, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forcemerge<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesForcemerge, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    freeze<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesFreeze, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forcemerge<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesForcemergeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forcemerge<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesForcemergeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    freeze<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesFreezeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     freeze<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    freeze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesFreeze, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    freeze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesFreeze, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    freeze<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesFreezeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    freeze<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesFreezeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_alias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_alias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_alias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_alias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_alias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAlias<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetAlias, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_alias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetAliasRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_alias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetAliasRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAlias<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetAliasRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getAlias<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetAlias, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getAlias<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetAlias, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_stream<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetDataStream, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getAlias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetAliasRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getAlias<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetAliasRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_data_stream<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_data_stream<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_stream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetDataStream, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_stream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetDataStream, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataStream<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetDataStream, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_data_stream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetDataStreamRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_data_stream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetDataStreamRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDataStream<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetDataStreamRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getDataStream<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataStream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetDataStream, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataStream<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetDataStream, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_field_mapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetFieldMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDataStream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetDataStreamRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDataStream<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetDataStreamRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_field_mapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetFieldMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_field_mapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_field_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_field_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetFieldMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_field_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetFieldMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_field_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetFieldMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetFieldMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getFieldMapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetFieldMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_index_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetFieldMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getFieldMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetFieldMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_index_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_index_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_index_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_index_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetIndexTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_index_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetIndexTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_index_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetIndexTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetIndexTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetIndexTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_mapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetIndexTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getIndexTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetIndexTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_mapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_mapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getMapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_settings<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetSettings, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_settings<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_settings<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_settings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetSettings, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_settings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetSettings, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetSettings, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_settings<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetSettingsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_settings<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetSettingsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetSettingsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getSettings<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetSettings, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getSettings<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetSettings, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_template<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetSettingsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getSettings<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetSettingsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_template<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_template<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_template<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTemplate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetTemplate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_template<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTemplate<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetTemplateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTemplate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetTemplate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTemplate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetTemplate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_upgrade<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetUpgrade, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetTemplateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTemplate<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetTemplateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_upgrade<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetUpgradeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_upgrade<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_upgrade<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetUpgrade, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_upgrade<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetUpgrade, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesGetUpgrade, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_upgrade<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetUpgradeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_upgrade<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetUpgradeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesGetUpgradeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getUpgrade<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetUpgrade, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesGetUpgrade, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    open<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesOpen, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetUpgradeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getUpgrade<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesGetUpgradeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    open<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesOpenRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     open<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    open<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesOpen, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    open<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesOpen, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutAlias<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    open<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesOpenRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    open<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesOpenRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutAliasRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutAlias<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutAlias<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutAlias<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutAliasRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_alias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutAliasRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutAliasRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutAlias<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutAlias<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutIndexTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutAliasRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putAlias<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutAliasRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutIndexTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutIndexTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutIndexTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutIndexTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutIndexTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutIndexTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutMapping<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutIndexTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutIndexTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutMappingRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutMapping<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutMapping<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutMapping<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutMappingRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutMappingRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutMappingRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutMapping<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutMapping<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutMappingRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutMappingRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutSettings<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutSettings<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutSettingsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutSettingsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutSettings<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutSettings<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutSettingsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutSettingsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesPutTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesPutTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesPutTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    recovery<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesRecovery, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesPutTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    recovery<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesRecoveryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     recovery<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    recovery<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesRecovery, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    recovery<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesRecovery, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    refresh<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesRefresh, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    recovery<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesRecoveryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    recovery<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesRecoveryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    refresh<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesRefreshRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     refresh<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    refresh<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesRefresh, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    refresh<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesRefresh, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesReloadSearchAnalyzers, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    refresh<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesRefreshRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    refresh<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesRefreshRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesReloadSearchAnalyzers, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesReloadSearchAnalyzersRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reload_search_analyzers<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesReloadSearchAnalyzersRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesReloadSearchAnalyzersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesReloadSearchAnalyzers, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resolve_index<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesResolveIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesReloadSearchAnalyzersRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reloadSearchAnalyzers<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesReloadSearchAnalyzersRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resolve_index<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     resolve_index<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resolve_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesResolveIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resolve_index<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesResolveIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesResolveIndex, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resolve_index<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesResolveIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resolve_index<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesResolveIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesResolveIndexRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     resolveIndex<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesResolveIndex, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesResolveIndex, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesRollover<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesResolveIndexRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    resolveIndex<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesResolveIndexRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesRolloverRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesRollover<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesRollover<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    segments<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSegments, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesRolloverRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    rollover<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesRolloverRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    segments<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesSegmentsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     segments<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    segments<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSegments, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    segments<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSegments, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shard_stores<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesShardStores, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    segments<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesSegmentsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    segments<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesSegmentsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shard_stores<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesShardStoresRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     shard_stores<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shard_stores<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesShardStores, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shard_stores<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesShardStores, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shardStores<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesShardStores, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shard_stores<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesShardStoresRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shard_stores<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesShardStoresRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shardStores<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesShardStoresRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     shardStores<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shardStores<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesShardStores, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shardStores<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesShardStores, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesShrink<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shardStores<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesShardStoresRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shardStores<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesShardStoresRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesShrinkRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesShrink<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesShrink<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesShrinkRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    shrink<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesShrinkRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate_index_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateIndexTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSimulateTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulateIndexTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateIndexTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSimulateTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSimulateTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSimulateTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSimulateTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesSplit<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulateTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSimulateTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesSplitRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSplit<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesSplit<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSplitRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    split<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesSplitRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    unfreeze<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUnfreeze, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    unfreeze<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesUnfreezeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     unfreeze<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    unfreeze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUnfreeze, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    unfreeze<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUnfreeze, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUpdateAliases<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    unfreeze<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesUnfreezeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    unfreeze<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesUnfreezeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesUpdateAliasesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUpdateAliases<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUpdateAliases<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUpdateAliases<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesUpdateAliasesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_aliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesUpdateAliasesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesUpdateAliasesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUpdateAliases<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUpdateAliases<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    upgrade<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesUpgrade, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesUpdateAliasesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateAliases<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesUpdateAliasesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    upgrade<TResponse = Record<string, any>, TContext = Context>(params?: Req.IndicesUpgradeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     upgrade<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    upgrade<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUpgrade, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    upgrade<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IndicesUpgrade, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesValidateQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    upgrade<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesUpgradeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    upgrade<TResponse = Record<string, any>, TContext = Context>(params: Req.IndicesUpgradeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesValidateQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesValidateQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesValidateQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IndicesValidateQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesValidateQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validate_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesValidateQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IndicesValidateQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesValidateQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IndicesValidateQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesValidateQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validateQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IndicesValidateQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Info, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  info<TResponse = Record<string, any>, TContext = Context>(params?: Req.InfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   info<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Info, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Info, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  info<TResponse = Record<string, any>, TContext = Context>(params: Req.InfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  info<TResponse = Record<string, any>, TContext = Context>(params: Req.InfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   ingest: {
-    delete_pipeline<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_pipeline<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestDeletePipelineRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_pipeline<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_pipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestDeletePipeline, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_pipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestDeletePipeline, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestDeletePipeline, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_pipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestDeletePipelineRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_pipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestDeletePipelineRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestDeletePipelineRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deletePipeline<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestDeletePipeline, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestDeletePipeline, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_pipeline<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestGetPipeline, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestDeletePipelineRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deletePipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestDeletePipelineRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_pipeline<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestGetPipelineRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_pipeline<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_pipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestGetPipeline, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_pipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestGetPipeline, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPipeline<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestGetPipeline, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_pipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestGetPipelineRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_pipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestGetPipelineRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getPipeline<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestGetPipelineRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getPipeline<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestGetPipeline, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPipeline<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestGetPipeline, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    processor_grok<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestProcessorGrok, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getPipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestGetPipelineRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getPipeline<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestGetPipelineRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    processor_grok<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestProcessorGrokRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     processor_grok<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    processor_grok<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestProcessorGrok, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    processor_grok<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestProcessorGrok, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    processorGrok<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.IngestProcessorGrok, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    processor_grok<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestProcessorGrokRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    processor_grok<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestProcessorGrokRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    processorGrok<TResponse = Record<string, any>, TContext = Context>(params?: Req.IngestProcessorGrokRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     processorGrok<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    processorGrok<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestProcessorGrok, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    processorGrok<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.IngestProcessorGrok, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IngestPutPipeline<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    processorGrok<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestProcessorGrokRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    processorGrok<TResponse = Record<string, any>, TContext = Context>(params: Req.IngestProcessorGrokRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IngestPutPipelineRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IngestPutPipeline<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IngestPutPipeline<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IngestPutPipeline<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IngestPutPipelineRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_pipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IngestPutPipelineRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IngestPutPipelineRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IngestPutPipeline<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IngestPutPipeline<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.IngestSimulate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IngestPutPipelineRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putPipeline<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IngestPutPipelineRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.IngestSimulateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IngestSimulate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.IngestSimulate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IngestSimulateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    simulate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.IngestSimulateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   license: {
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseDelete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseDelete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseDeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseDeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_basic_status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGetBasicStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_basic_status<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetBasicStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_basic_status<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_basic_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_basic_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGetBasicStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_basic_status<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetBasicStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_basic_status<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetBasicStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetBasicStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getBasicStatus<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetBasicStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trial_status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGetTrialStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetBasicStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getBasicStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetBasicStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_trial_status<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetTrialStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_trial_status<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trial_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trial_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicenseGetTrialStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_trial_status<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetTrialStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_trial_status<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetTrialStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicenseGetTrialStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTrialStatus<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicenseGetTrialStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePost<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetTrialStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTrialStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.LicenseGetTrialStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.LicensePostRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.LicensePost<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.LicensePost<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_start_basic<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePostStartBasic, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.LicensePostRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.LicensePostRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_start_basic<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicensePostStartBasicRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     post_start_basic<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_start_basic<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartBasic, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_start_basic<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartBasic, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePostStartBasic, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post_start_basic<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartBasicRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_start_basic<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartBasicRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicensePostStartBasicRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     postStartBasic<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartBasic, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartBasic, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_start_trial<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePostStartTrial, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartBasicRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postStartBasic<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartBasicRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_start_trial<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicensePostStartTrialRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     post_start_trial<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_start_trial<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartTrial, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_start_trial<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartTrial, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.LicensePostStartTrial, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post_start_trial<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartTrialRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_start_trial<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartTrialRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params?: Req.LicensePostStartTrialRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     postStartTrial<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartTrial, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.LicensePostStartTrial, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartTrialRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postStartTrial<TResponse = Record<string, any>, TContext = Context>(params: Req.LicensePostStartTrialRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Mget<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MgetRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Mget<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Mget<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MgetRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  mget<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MgetRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   migration: {
-    deprecations<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MigrationDeprecations, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deprecations<TResponse = Record<string, any>, TContext = Context>(params?: Req.MigrationDeprecationsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deprecations<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deprecations<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MigrationDeprecations, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deprecations<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MigrationDeprecations, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deprecations<TResponse = Record<string, any>, TContext = Context>(params: Req.MigrationDeprecationsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deprecations<TResponse = Record<string, any>, TContext = Context>(params: Req.MigrationDeprecationsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   ml: {
-    close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlCloseJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlCloseJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlCloseJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlCloseJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlCloseJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlCloseJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    close_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlCloseJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlCloseJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlCloseJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlCloseJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendar, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlCloseJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    closeJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlCloseJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_calendar<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_calendar<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendar, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendar, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendar, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_calendar<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_calendar<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteCalendar<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendar, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendar, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendarEvent, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteCalendar<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarEventRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendarEvent, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarEventRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_calendar_event<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarEventRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarEventRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarEvent, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendarJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarEventRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteCalendarEvent<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarEventRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteCalendarJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteCalendarJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteCalendarJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteCalendarJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDataFrameAnalyticsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDataFrameAnalyticsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_datafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDataFrameAnalyticsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDataFrameAnalyticsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_datafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_datafeed<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_datafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDatafeed, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_datafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDatafeed, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_datafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDatafeedRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_datafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDatafeedRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDatafeed, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteDatafeed, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteExpiredData<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDatafeedRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteDatafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteDatafeedRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlDeleteExpiredDataRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteExpiredData<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteExpiredData<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteExpiredData<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlDeleteExpiredDataRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_expired_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlDeleteExpiredDataRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlDeleteExpiredDataRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteExpiredData<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteExpiredData<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_filter<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteFilter, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlDeleteExpiredDataRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteExpiredData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlDeleteExpiredDataRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_filter<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteFilterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_filter<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_filter<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteFilter, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_filter<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteFilter, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteFilter, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_filter<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteFilterRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_filter<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteFilterRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteFilterRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteFilter<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteFilter, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteFilter, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_forecast<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteForecast, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteFilterRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteFilter<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteFilterRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_forecast<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteForecastRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_forecast<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_forecast<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteForecast, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_forecast<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteForecast, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteForecast, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_forecast<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteForecastRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_forecast<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteForecastRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteForecastRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteForecast<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteForecast, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteForecast, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteForecastRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteForecast<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteForecastRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteModelSnapshot, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteModelSnapshotRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_model_snapshot<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteModelSnapshotRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteModelSnapshotRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteModelSnapshot, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_trained_model<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteTrainedModel, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteModelSnapshotRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteModelSnapshot<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteModelSnapshotRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_trained_model<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_trained_model<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_trained_model<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_trained_model<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlDeleteTrainedModel, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_trained_model<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteTrainedModelRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_trained_model<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteTrainedModelRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlDeleteTrainedModelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlDeleteTrainedModel, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlEstimateModelMemory<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteTrainedModelRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTrainedModel<TResponse = Record<string, any>, TContext = Context>(params: Req.MlDeleteTrainedModelRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlEstimateModelMemoryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEstimateModelMemory<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEstimateModelMemory<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlEstimateModelMemory<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEstimateModelMemoryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    estimate_model_memory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEstimateModelMemoryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlEstimateModelMemoryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEstimateModelMemory<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEstimateModelMemory<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlEvaluateDataFrame<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEstimateModelMemoryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    estimateModelMemory<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEstimateModelMemoryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlEvaluateDataFrameRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEvaluateDataFrame<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEvaluateDataFrame<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlEvaluateDataFrame<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEvaluateDataFrameRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    evaluate_data_frame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEvaluateDataFrameRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlEvaluateDataFrameRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEvaluateDataFrame<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlEvaluateDataFrame<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEvaluateDataFrameRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    evaluateDataFrame<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlEvaluateDataFrameRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explain_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlExplainDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MlFindFileStructure<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    explainDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlExplainDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MlFindFileStructureRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MlFindFileStructure<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MlFindFileStructure<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MlFindFileStructure<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MlFindFileStructureRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    find_file_structure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MlFindFileStructureRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MlFindFileStructureRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MlFindFileStructure<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MlFindFileStructure<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlFlushJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MlFindFileStructureRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    findFileStructure<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MlFindFileStructureRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlFlushJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlFlushJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlFlushJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlFlushJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlFlushJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    flush_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlFlushJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlFlushJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlFlushJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlFlushJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forecast<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlForecast, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlFlushJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    flushJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlFlushJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forecast<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlForecastRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     forecast<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forecast<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlForecast, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    forecast<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlForecast, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetBuckets<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    forecast<TResponse = Record<string, any>, TContext = Context>(params: Req.MlForecastRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    forecast<TResponse = Record<string, any>, TContext = Context>(params: Req.MlForecastRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetBucketsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetBuckets<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetBuckets<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetBuckets<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetBucketsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetBucketsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetBucketsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetBuckets<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetBuckets<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_calendar_events<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetBucketsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetBucketsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_calendar_events<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetCalendarEventsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_calendar_events<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_calendar_events<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendarEvents, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_calendar_events<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendarEvents, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCalendarEvents, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_calendar_events<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarEventsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_calendar_events<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarEventsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetCalendarEventsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendarEvents, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendarEvents, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCalendars<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarEventsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getCalendarEvents<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarEventsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetCalendarsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendars<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendars<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCalendars<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_calendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetCalendarsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendars<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCalendars<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCategories<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getCalendars<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCalendarsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetCategoriesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCategories<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCategories<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetCategories<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCategoriesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_categories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCategoriesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetCategoriesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCategories<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetCategories<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCategoriesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getCategories<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetCategoriesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalytics, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_data_frame_analytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDataFrameAnalyticsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalytics, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalyticsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDataFrameAnalytics<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDataFrameAnalyticsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDataFrameAnalyticsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_data_frame_analytics_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDataFrameAnalyticsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDataFrameAnalyticsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDatafeedStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDataFrameAnalyticsStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDataFrameAnalyticsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDatafeedStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeedStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeedStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDatafeedStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_datafeed_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDatafeedStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeedStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeedStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_datafeeds<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDatafeeds, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDatafeedStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_datafeeds<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDatafeedsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_datafeeds<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeeds, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeeds, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetDatafeeds, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_datafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetDatafeedsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getDatafeeds<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeeds, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetDatafeeds, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_filters<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetFilters, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getDatafeeds<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetDatafeedsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_filters<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetFiltersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_filters<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_filters<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetFilters, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_filters<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetFilters, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getFilters<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetFilters, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_filters<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetFiltersRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_filters<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetFiltersRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getFilters<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetFiltersRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getFilters<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getFilters<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetFilters, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getFilters<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetFilters, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetInfluencers<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getFilters<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetFiltersRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getFilters<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetFiltersRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetInfluencersRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetInfluencers<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetInfluencers<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetInfluencers<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetInfluencersRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_influencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetInfluencersRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetInfluencersRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetInfluencers<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetInfluencers<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_job_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetJobStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetInfluencersRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getInfluencers<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetInfluencersRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_job_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetJobStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_job_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_job_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_job_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetJobStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_job_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_job_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getJobStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetJobStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getJobStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_jobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getJobStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getJobStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_jobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_jobs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getJobs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetJobs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetModelSnapshots<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetJobsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetModelSnapshotsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetModelSnapshots<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetModelSnapshots<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetModelSnapshots<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetModelSnapshotsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_model_snapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetModelSnapshotsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetModelSnapshotsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetModelSnapshots<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetModelSnapshots<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetOverallBuckets<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetModelSnapshotsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getModelSnapshots<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetModelSnapshotsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetOverallBucketsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetOverallBuckets<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetOverallBuckets<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetOverallBuckets<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetOverallBucketsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_overall_buckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetOverallBucketsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetOverallBucketsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetOverallBuckets<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetOverallBuckets<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetRecords<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetOverallBucketsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getOverallBuckets<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetOverallBucketsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetRecordsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetRecords<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetRecords<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetRecords<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetRecordsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_records<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetRecordsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlGetRecordsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetRecords<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlGetRecords<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trained_models<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetTrainedModels, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetRecordsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRecords<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlGetRecordsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_trained_models<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetTrainedModelsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_trained_models<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trained_models<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModels, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trained_models<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModels, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetTrainedModels, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_trained_models<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_trained_models<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetTrainedModelsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTrainedModels<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModels, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModels, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetTrainedModelsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTrainedModels<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetTrainedModelsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlGetTrainedModelsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_trained_models_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlGetTrainedModelsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlGetTrainedModelsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTrainedModelsStats<TResponse = Record<string, any>, TContext = Context>(params: Req.MlGetTrainedModelsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    info<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     info<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    open_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlOpenJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params: Req.MlInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    info<TResponse = Record<string, any>, TContext = Context>(params: Req.MlInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    open_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlOpenJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     open_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    open_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlOpenJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    open_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlOpenJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    openJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlOpenJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    open_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlOpenJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    open_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlOpenJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    openJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlOpenJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     openJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    openJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlOpenJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    openJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlOpenJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPostCalendarEvents<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    openJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlOpenJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    openJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlOpenJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPostCalendarEventsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostCalendarEvents<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostCalendarEvents<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPostCalendarEvents<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostCalendarEventsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_calendar_events<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostCalendarEventsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPostCalendarEventsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostCalendarEvents<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostCalendarEvents<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPostData<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostCalendarEventsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postCalendarEvents<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostCalendarEventsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPostDataRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostData<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostData<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPostData<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostDataRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    post_data<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostDataRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPostDataRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostData<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPostData<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_datafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlPreviewDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostDataRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    postData<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPostDataRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_datafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlPreviewDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     preview_datafeed<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_datafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPreviewDatafeed, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_datafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPreviewDatafeed, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlPreviewDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    preview_datafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPreviewDatafeedRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_datafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPreviewDatafeedRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlPreviewDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     previewDatafeed<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPreviewDatafeed, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPreviewDatafeed, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutCalendar<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPreviewDatafeedRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewDatafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPreviewDatafeedRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutCalendarRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendar<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendar<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutCalendar<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_calendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutCalendarRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendar<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendar<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_calendar_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutCalendarJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putCalendar<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_calendar_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlPutCalendarJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_calendar_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendarJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendarJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutCalendarJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_calendar_job<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlPutCalendarJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putCalendarJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendarJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlPutCalendarJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putCalendarJob<TResponse = Record<string, any>, TContext = Context>(params: Req.MlPutCalendarJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDatafeed<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDatafeed<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDatafeedRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDatafeedRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDatafeed<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutDatafeed<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutFilter<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDatafeedRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutDatafeedRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutFilterRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutFilter<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutFilter<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutFilter<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutFilterRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutFilterRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutFilterRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutFilter<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutFilter<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutFilterRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutFilterRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutTrainedModel<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutTrainedModelRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutTrainedModel<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutTrainedModel<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlPutTrainedModel<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutTrainedModelRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_trained_model<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutTrainedModelRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlPutTrainedModelRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutTrainedModel<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlPutTrainedModel<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlRevertModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutTrainedModelRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTrainedModel<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlPutTrainedModelRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlRevertModelSnapshotRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlRevertModelSnapshot<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlRevertModelSnapshot<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlRevertModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlRevertModelSnapshotRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    revert_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlRevertModelSnapshotRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlRevertModelSnapshotRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlRevertModelSnapshot<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlRevertModelSnapshot<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlSetUpgradeMode, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlRevertModelSnapshotRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    revertModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlRevertModelSnapshotRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlSetUpgradeModeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlSetUpgradeMode, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlSetUpgradeMode, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlSetUpgradeMode, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(params: Req.MlSetUpgradeModeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    set_upgrade_mode<TResponse = Record<string, any>, TContext = Context>(params: Req.MlSetUpgradeModeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlSetUpgradeModeRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlSetUpgradeMode, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlSetUpgradeMode, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params: Req.MlSetUpgradeModeRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    setUpgradeMode<TResponse = Record<string, any>, TContext = Context>(params: Req.MlSetUpgradeModeRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStartDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStartDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDatafeed<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDatafeed<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStartDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDatafeedRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDatafeedRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStartDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDatafeed<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStartDatafeed<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDatafeedRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStartDatafeedRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_datafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlStopDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlStopDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_datafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlStopDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop_datafeed<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_datafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDatafeed, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_datafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDatafeed, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.MlStopDatafeed, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop_datafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlStopDatafeedRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_datafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlStopDatafeedRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params?: Req.MlStopDatafeedRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stopDatafeed<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDatafeed, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.MlStopDatafeed, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlStopDatafeedRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopDatafeed<TResponse = Record<string, any>, TContext = Context>(params: Req.MlStopDatafeedRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_data_frame_analytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDataFrameAnalytics<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateDataFrameAnalytics<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDataFrameAnalyticsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDatafeed<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDatafeed<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateDatafeed<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDatafeedRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_datafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDatafeedRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateDatafeedRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDatafeed<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateDatafeed<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateFilter<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDatafeedRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateDatafeed<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateDatafeedRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateFilterRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateFilter<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateFilter<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateFilter<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateFilterRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_filter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateFilterRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateFilterRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateFilter<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateFilter<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateFilterRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateFilter<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateFilterRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateModelSnapshotRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlUpdateModelSnapshot<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateModelSnapshotRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_model_snapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateModelSnapshotRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlUpdateModelSnapshotRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlUpdateModelSnapshot<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlValidate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateModelSnapshotRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateModelSnapshot<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlUpdateModelSnapshotRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlValidateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlValidate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlValidate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlValidateDetector<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlValidateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlValidateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlValidateDetectorRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlValidateDetector<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlValidateDetector<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.MlValidateDetector<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlValidateDetectorRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validate_detector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlValidateDetectorRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MlValidateDetectorRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlValidateDetector<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.MlValidateDetector<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlValidateDetectorRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    validateDetector<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MlValidateDetectorRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   monitoring: {
-    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MonitoringBulk<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MonitoringBulkRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MonitoringBulk<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MonitoringBulk<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MonitoringBulkRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    bulk<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MonitoringBulkRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.Msearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MsearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.Msearch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.Msearch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MsearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MsearchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  msearch<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MsearchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MsearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MsearchTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MsearchTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: RequestParams.MsearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MsearchTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  msearch_template<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MsearchTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params?: Req.MsearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MsearchTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: RequestParams.MsearchTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Mtermvectors<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MsearchTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  msearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestNDBody = Record<string, any>[], TContext = Context>(params: Req.MsearchTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.MtermvectorsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Mtermvectors<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Mtermvectors<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MtermvectorsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  mtermvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.MtermvectorsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   nodes: {
-    hot_threads<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesHotThreads, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    hot_threads<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesHotThreadsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     hot_threads<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hot_threads<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesHotThreads, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hot_threads<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesHotThreads, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hotThreads<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesHotThreads, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    hot_threads<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesHotThreadsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    hot_threads<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesHotThreadsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    hotThreads<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesHotThreadsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     hotThreads<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hotThreads<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesHotThreads, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hotThreads<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesHotThreads, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    hotThreads<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesHotThreadsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    hotThreads<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesHotThreadsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    info<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     info<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.NodesReloadSecureSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    info<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.NodesReloadSecureSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.NodesReloadSecureSettings<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.NodesReloadSecureSettings<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.NodesReloadSecureSettings<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.NodesReloadSecureSettingsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reload_secure_settings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.NodesReloadSecureSettingsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.NodesReloadSecureSettingsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.NodesReloadSecureSettings<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.NodesReloadSecureSettings<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.NodesReloadSecureSettingsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    reloadSecureSettings<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.NodesReloadSecureSettingsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    usage<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.NodesUsage, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    usage<TResponse = Record<string, any>, TContext = Context>(params?: Req.NodesUsageRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     usage<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    usage<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesUsage, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    usage<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.NodesUsage, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    usage<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesUsageRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    usage<TResponse = Record<string, any>, TContext = Context>(params: Req.NodesUsageRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  ping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.Ping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  ping<TResponse = Record<string, any>, TContext = Context>(params?: Req.PingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   ping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  ping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Ping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  ping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.Ping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.PutScript<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  ping<TResponse = Record<string, any>, TContext = Context>(params: Req.PingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  ping<TResponse = Record<string, any>, TContext = Context>(params: Req.PingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.PutScriptRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.PutScript<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.PutScript<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.PutScript<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.PutScriptRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  put_script<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.PutScriptRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.PutScriptRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.PutScript<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.PutScript<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RankEval<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.PutScriptRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  putScript<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.PutScriptRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RankEvalRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RankEval<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RankEval<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RankEval<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RankEvalRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  rank_eval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RankEvalRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RankEvalRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RankEval<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RankEval<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Reindex<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RankEvalRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  rankEval<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RankEvalRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ReindexRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Reindex<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Reindex<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ReindexRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ReindexRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  reindex<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ReindexRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.ReindexRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ReindexRethrottle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ReindexRethrottle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.ReindexRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.ReindexRethrottleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  reindex_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.ReindexRethrottleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.ReindexRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ReindexRethrottle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.ReindexRethrottle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RenderSearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.ReindexRethrottleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  reindexRethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.ReindexRethrottleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RenderSearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RenderSearchTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RenderSearchTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RenderSearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RenderSearchTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  render_search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RenderSearchTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RenderSearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RenderSearchTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RenderSearchTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RenderSearchTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  renderSearchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RenderSearchTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   rollup: {
-    delete_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupDeleteJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupDeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupDeleteJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupDeleteJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupDeleteJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_job<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupDeleteJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_job<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupDeleteJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupDeleteJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupDeleteJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupDeleteJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_jobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupDeleteJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteJob<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupDeleteJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_jobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_jobs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetJobs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetJobs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetJobs, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetJobsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_jobs<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetJobsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetJobsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getJobs<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetJobs, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getJobs<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetJobs, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetRollupCaps, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetJobsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getJobs<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetJobsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetRollupCapsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupCaps, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupCaps, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetRollupCaps, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupCapsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_rollup_caps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupCapsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetRollupCapsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getRollupCaps<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupCaps, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupCaps, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetRollupIndexCaps, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupCapsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRollupCaps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupCapsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetRollupIndexCapsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupGetRollupIndexCaps, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupIndexCapsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_rollup_index_caps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupIndexCapsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupGetRollupIndexCapsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupGetRollupIndexCaps, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RollupPutJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupIndexCapsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRollupIndexCaps<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupGetRollupIndexCapsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RollupPutJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupPutJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupPutJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RollupPutJob<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupPutJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_job<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupPutJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RollupPutJobRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupPutJob<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupPutJob<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RollupRollupSearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupPutJobRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putJob<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupPutJobRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RollupRollupSearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupRollupSearch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupRollupSearch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.RollupRollupSearch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupRollupSearchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    rollup_search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupRollupSearchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.RollupRollupSearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupRollupSearch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.RollupRollupSearch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupStartJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupRollupSearchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    rollupSearch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.RollupRollupSearchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupStartJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStartJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStartJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupStartJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start_job<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStartJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_job<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStartJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupStartJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     startJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStartJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStartJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_job<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupStopJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startJob<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStartJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startJob<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStartJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_job<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupStopJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop_job<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStopJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_job<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStopJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopJob<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.RollupStopJob, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop_job<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStopJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_job<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStopJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopJob<TResponse = Record<string, any>, TContext = Context>(params?: Req.RollupStopJobRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stopJob<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStopJob, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopJob<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.RollupStopJob, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopJob<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStopJobRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopJob<TResponse = Record<string, any>, TContext = Context>(params: Req.RollupStopJobRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ScriptsPainlessExecute<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ScriptsPainlessExecuteRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ScriptsPainlessExecute<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ScriptsPainlessExecute<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.ScriptsPainlessExecute<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ScriptsPainlessExecuteRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  scripts_painless_execute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ScriptsPainlessExecuteRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ScriptsPainlessExecuteRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ScriptsPainlessExecute<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.ScriptsPainlessExecute<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Scroll<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ScriptsPainlessExecuteRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  scriptsPainlessExecute<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ScriptsPainlessExecuteRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.ScrollRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Scroll<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Scroll<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Search<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Search<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Search<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search_shards<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchShards, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ScrollRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  scroll<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.ScrollRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search<TResponse = Res.SearchResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  search<TResponse = Res.SearchResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search<TResponse = Res.SearchResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search<TResponse = Res.SearchResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search_shards<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchShardsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   search_shards<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search_shards<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchShards, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search_shards<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchShards, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  searchShards<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchShards, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  search_shards<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchShardsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search_shards<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchShardsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  searchShards<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchShardsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   searchShards<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  searchShards<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchShards, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  searchShards<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchShards, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  searchShards<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchShardsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  searchShards<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchShardsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SearchTemplate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  search_template<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchTemplateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchTemplate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchTemplate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchTemplateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  searchTemplate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchTemplateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   searchable_snapshots: {
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cache<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCache<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsMount<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsMountRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsMount<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsMount<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repository_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsRepositoryStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsMountRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsMountRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsRepositoryStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     repository_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsRepositoryStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsRepositoryStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     repositoryStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   searchableSnapshots: {
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cache<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsClearCache, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsClearCacheRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCache<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCache<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsClearCache, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsMount<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCache<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsClearCacheRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsMountRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsMount<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsMount<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repository_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsRepositoryStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsMountRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    mount<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsMountRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsRepositoryStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     repository_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsRepositoryStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repository_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsRepositoryStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     repositoryStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsRepositoryStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SearchableSnapshotsStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    repositoryStats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsRepositoryStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SearchableSnapshotsStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SearchableSnapshotsStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SearchableSnapshotsStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   security: {
-    authenticate<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityAuthenticate, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    authenticate<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityAuthenticateRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     authenticate<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    authenticate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityAuthenticate, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    authenticate<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityAuthenticate, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityChangePassword<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    authenticate<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityAuthenticateRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    authenticate<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityAuthenticateRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityChangePasswordRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityChangePassword<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityChangePassword<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityChangePassword<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityChangePasswordRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    change_password<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityChangePasswordRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityChangePasswordRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityChangePassword<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityChangePassword<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityChangePasswordRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    changePassword<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityChangePasswordRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cached_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedRealms, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCachedPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedRealms, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRealmsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cached_realms<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRealmsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedRealmsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRealms, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedRoles, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRealmsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCachedRealms<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRealmsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedRolesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityClearCachedRoles, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRolesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cached_roles<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRolesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityClearCachedRolesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityClearCachedRoles, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityCreateApiKey<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRolesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCachedRoles<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityClearCachedRolesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityCreateApiKeyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityCreateApiKey<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityCreateApiKey<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityCreateApiKey<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityCreateApiKeyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityCreateApiKeyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityCreateApiKeyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityCreateApiKey<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityCreateApiKey<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_privileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeletePrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityCreateApiKeyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    createApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityCreateApiKeyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_privileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeletePrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_privileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeletePrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeletePrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeletePrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeletePrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deletePrivileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeletePrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_role<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteRole, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeletePrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deletePrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeletePrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_role<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_role<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_role<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRole, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_role<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRole, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRole<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteRole, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_role<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_role<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteRole<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteRole<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRole<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRole, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRole<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRole, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteRoleMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteRole<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteRole<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteRoleMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteRoleMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_user<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteRoleMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_user<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_user<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDeleteUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDeleteUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteUser<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDeleteUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    disable_user<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDisableUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDeleteUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    disable_user<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDisableUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     disable_user<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    disable_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDisableUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    disable_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDisableUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    disableUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityDisableUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    disable_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDisableUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    disable_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDisableUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    disableUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityDisableUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     disableUser<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    disableUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDisableUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    disableUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityDisableUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    enable_user<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityEnableUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    disableUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDisableUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    disableUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityDisableUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    enable_user<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityEnableUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     enable_user<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    enable_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityEnableUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    enable_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityEnableUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    enableUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityEnableUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    enable_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityEnableUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    enable_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityEnableUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    enableUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityEnableUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     enableUser<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    enableUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityEnableUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    enableUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityEnableUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_api_key<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetApiKey, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    enableUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityEnableUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    enableUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityEnableUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_api_key<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetApiKeyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_api_key<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_api_key<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetApiKey, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_api_key<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetApiKey, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getApiKey<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetApiKey, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_api_key<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetApiKeyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_api_key<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetApiKeyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getApiKey<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetApiKeyRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getApiKey<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getApiKey<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetApiKey, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getApiKey<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetApiKey, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetBuiltinPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getApiKey<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetApiKeyRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getApiKey<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetApiKeyRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetBuiltinPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetBuiltinPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetBuiltinPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_builtin_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetBuiltinPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetBuiltinPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetBuiltinPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_privileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetBuiltinPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getBuiltinPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetBuiltinPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_privileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_privileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getPrivileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_role<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetRole, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_role<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_role<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_role<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRole, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_role<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRole, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRole<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetRole, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_role<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_role<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRole<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetRoleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getRole<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRole<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRole, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRole<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRole, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_role_mapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetRoleMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRole<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRole<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_role_mapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_role_mapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetRoleMapping, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_role_mapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetRoleMappingRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getRoleMapping<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetRoleMapping, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetToken<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleMappingRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRoleMapping<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetRoleMappingRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityGetTokenRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetToken<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetToken<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetToken<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityGetTokenRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityGetTokenRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityGetTokenRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetToken<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetToken<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_user<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityGetTokenRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityGetTokenRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_user<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_user<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_user<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUser<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetUser, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_user<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getUser<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetUserRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getUser<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUser, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUser<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUser, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_user_privileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetUserPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getUser<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_user_privileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetUserPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_user_privileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_user_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_user_privileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityGetUserPrivileges, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_user_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_user_privileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params?: Req.SecurityGetUserPrivilegesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SecurityGetUserPrivileges, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityHasPrivileges<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserPrivilegesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getUserPrivileges<TResponse = Record<string, any>, TContext = Context>(params: Req.SecurityGetUserPrivilegesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityHasPrivilegesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityHasPrivileges<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityHasPrivileges<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityHasPrivileges<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityHasPrivilegesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    has_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityHasPrivilegesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityHasPrivilegesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityHasPrivileges<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityHasPrivileges<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityInvalidateApiKey<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityHasPrivilegesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    hasPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityHasPrivilegesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityInvalidateApiKey<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidate_api_key<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateApiKey<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityInvalidateToken<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidateApiKey<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateApiKeyRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityInvalidateTokenRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateToken<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateToken<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityInvalidateToken<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateTokenRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidate_token<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateTokenRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityInvalidateTokenRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateToken<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityInvalidateToken<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutPrivileges<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateTokenRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    invalidateToken<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityInvalidateTokenRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutPrivilegesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutPrivileges<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutPrivileges<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutPrivileges<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutPrivilegesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_privileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutPrivilegesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutPrivilegesRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutPrivileges<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutPrivileges<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutRole<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutPrivilegesRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putPrivileges<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutPrivilegesRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutRoleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRole<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRole<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutRole<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_role<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutRoleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRole<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRole<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutRoleMapping<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putRole<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutRoleMappingRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRoleMapping<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRoleMapping<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutRoleMapping<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleMappingRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_role_mapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleMappingRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutRoleMappingRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRoleMapping<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutRoleMapping<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutUser<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleMappingRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putRoleMapping<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutRoleMappingRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutUserRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutUser<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutUser<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SecurityPutUser<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutUserRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_user<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutUserRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SecurityPutUserRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutUser<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SecurityPutUser<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutUserRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putUser<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SecurityPutUserRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   slm: {
-    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmDeleteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmDeleteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmDeleteLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmDeleteLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmDeleteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmDeleteLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmExecuteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmDeleteLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmDeleteLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmExecuteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmExecuteLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmExecuteLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     executeLifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_retention<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmExecuteRetention, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executeLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_retention<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmExecuteRetentionRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     execute_retention<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_retention<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteRetention, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_retention<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteRetention, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeRetention<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmExecuteRetention, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    execute_retention<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteRetentionRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_retention<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteRetentionRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executeRetention<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmExecuteRetentionRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     executeRetention<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeRetention<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteRetention, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeRetention<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmExecuteRetention, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executeRetention<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteRetentionRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executeRetention<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmExecuteRetentionRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_lifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetLifecycle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_lifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetLifecycleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getLifecycle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetLifecycle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetLifecycle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetLifecycleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getLifecycle<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetLifecycleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getStats<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getStats<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_status<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_status<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmGetStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_status<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_status<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmGetStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getStatus<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getStatus<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmGetStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SlmPutLifecycle<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getStatus<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmGetStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SlmPutLifecycleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SlmPutLifecycle<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SlmPutLifecycle<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SlmPutLifecycle<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SlmPutLifecycleRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_lifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SlmPutLifecycleRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SlmPutLifecycleRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SlmPutLifecycle<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SlmPutLifecycle<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmStart, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SlmPutLifecycleRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putLifecycle<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SlmPutLifecycleRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmStartRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmStart, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmStart, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SlmStop, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmStartRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmStartRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params?: Req.SlmStopRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmStop, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SlmStop, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmStopRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params: Req.SlmStopRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   snapshot: {
-    cleanup_repository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCleanupRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cleanup_repository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotCleanupRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     cleanup_repository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cleanup_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cleanup_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCleanupRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cleanup_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotCleanupRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    cleanup_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotCleanupRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotCleanupRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     cleanupRepository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCleanupRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCreate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotCleanupRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    cleanupRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotCleanupRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotCreateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCreate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCreate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCreateRepository<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotCreateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotCreateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotCreateRepositoryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCreateRepository<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCreateRepository<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotCreateRepository<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotCreateRepositoryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    create_repository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotCreateRepositoryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotCreateRepositoryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCreateRepository<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotCreateRepository<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotDelete, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotCreateRepositoryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    createRepository<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotCreateRepositoryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotDeleteRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotDelete, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotDelete, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_repository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotDeleteRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotDeleteRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotDeleteRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_repository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotDeleteRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_repository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotDeleteRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotDeleteRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotDeleteRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotDeleteRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteRepository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotDeleteRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotDeleteRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotDeleteRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_repository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotGetRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_repository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotGetRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_repository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGetRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGetRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotGetRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotGetRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotGetRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotGetRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getRepository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGetRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotGetRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotRestore<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotGetRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotGetRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SnapshotRestoreRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRestore<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotRestore<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    status<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotStatus, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotRestoreRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    restore<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SnapshotRestoreRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    status<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotStatusRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     status<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotStatus, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    status<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotStatus, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    verify_repository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotVerifyRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    status<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotStatusRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    status<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotStatusRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    verify_repository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotVerifyRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     verify_repository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    verify_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    verify_repository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SnapshotVerifyRepository, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    verify_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotVerifyRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    verify_repository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotVerifyRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params?: Req.SnapshotVerifyRepositoryRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     verifyRepository<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SnapshotVerifyRepository, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotVerifyRepositoryRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    verifyRepository<TResponse = Record<string, any>, TContext = Context>(params: Req.SnapshotVerifyRepositoryRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   sql: {
-    clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlClearCursor<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlClearCursorRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlClearCursor<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlClearCursor<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlClearCursor<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlClearCursorRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clear_cursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlClearCursorRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlClearCursorRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlClearCursor<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlClearCursor<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlClearCursorRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    clearCursor<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlClearCursorRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.SqlTranslate<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.SqlTranslateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlTranslate<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.SqlTranslate<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlTranslateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    translate<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.SqlTranslateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   ssl: {
-    certificates<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.SslCertificates, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    certificates<TResponse = Record<string, any>, TContext = Context>(params?: Req.SslCertificatesRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     certificates<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    certificates<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SslCertificates, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    certificates<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.SslCertificates, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    certificates<TResponse = Record<string, any>, TContext = Context>(params: Req.SslCertificatesRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    certificates<TResponse = Record<string, any>, TContext = Context>(params: Req.SslCertificatesRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   tasks: {
-    cancel<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TasksCancel, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cancel<TResponse = Record<string, any>, TContext = Context>(params?: Req.TasksCancelRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     cancel<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cancel<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TasksCancel, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    cancel<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TasksCancel, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TasksGet, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    cancel<TResponse = Record<string, any>, TContext = Context>(params: Req.TasksCancelRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    cancel<TResponse = Record<string, any>, TContext = Context>(params: Req.TasksCancelRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params?: Req.TasksGetRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TasksGet, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TasksGet, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TasksList, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.TasksGetRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get<TResponse = Record<string, any>, TContext = Context>(params: Req.TasksGetRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list<TResponse = Record<string, any>, TContext = Context>(params?: Req.TasksListRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     list<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TasksList, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    list<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TasksList, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list<TResponse = Record<string, any>, TContext = Context>(params: Req.TasksListRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    list<TResponse = Record<string, any>, TContext = Context>(params: Req.TasksListRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Termvectors<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TermvectorsRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Termvectors<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Termvectors<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TermvectorsRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  termvectors<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TermvectorsRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   transform: {
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformDeleteTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformDeleteTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformDeleteTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformDeleteTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformDeleteTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformDeleteTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformDeleteTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformDeleteTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformDeleteTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformDeleteTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformGetTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformGetTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_transform_stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransformStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransformStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformGetTransformStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_transform_stats<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformGetTransformStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getTransformStats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransformStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformGetTransformStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getTransformStats<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformGetTransformStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPreviewTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPreviewTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformPreviewTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPreviewTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    preview_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPreviewTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformPreviewTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPreviewTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPreviewTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPreviewTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    previewTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPreviewTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPutTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPutTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformPutTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPutTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPutTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformPutTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPutTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformPutTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPutTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformPutTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStartTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStartTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformStartTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStartTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStartTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformStartTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     startTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStartTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    startTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStartTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStartTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    startTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStartTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop_transform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStopTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStopTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.TransformStopTransform, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStopTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop_transform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStopTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params?: Req.TransformStopTransformRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stopTransform<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStopTransform, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.TransformStopTransform, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStopTransformRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stopTransform<TResponse = Record<string, any>, TContext = Context>(params: Req.TransformStopTransformRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformUpdateTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformUpdateTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.TransformUpdateTransform<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformUpdateTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    update_transform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformUpdateTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.TransformUpdateTransformRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformUpdateTransform<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.TransformUpdateTransform<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformUpdateTransformRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    updateTransform<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.TransformUpdateTransformRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
-  update<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.Update<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
-  update<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Update<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.Update<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.UpdateByQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  update<TResponse = Res.UpdateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.UpdateRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  update<TResponse = Res.UpdateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  update<TResponse = Res.UpdateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.UpdateRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  update<TResponse = Res.UpdateResponse, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.UpdateRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.UpdateByQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.UpdateByQuery<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  update_by_query<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.UpdateByQueryRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQuery<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQuery<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.UpdateByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  updateByQuery<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.UpdateByQueryRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.UpdateByQueryRethrottle, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+  update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRethrottleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  update_by_query_rethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRethrottleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params?: Req.UpdateByQueryRethrottleRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
   updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.UpdateByQueryRethrottle, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRethrottleRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+  updateByQueryRethrottle<TResponse = Record<string, any>, TContext = Context>(params: Req.UpdateByQueryRethrottleRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   watcher: {
-    ack_watch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherAckWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ack_watch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherAckWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     ack_watch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ack_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherAckWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ack_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherAckWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ackWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherAckWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ack_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherAckWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ack_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherAckWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ackWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherAckWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     ackWatch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ackWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherAckWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    ackWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherAckWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    activate_watch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherActivateWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    ackWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherAckWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    ackWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherAckWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    activate_watch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherActivateWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     activate_watch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    activate_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherActivateWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    activate_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherActivateWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    activateWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherActivateWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    activate_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherActivateWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    activate_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherActivateWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    activateWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherActivateWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     activateWatch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    activateWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherActivateWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    activateWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherActivateWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deactivate_watch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherDeactivateWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    activateWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherActivateWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    activateWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherActivateWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deactivate_watch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherDeactivateWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deactivate_watch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deactivate_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deactivate_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherDeactivateWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deactivate_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeactivateWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deactivate_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeactivateWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherDeactivateWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deactivateWatch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeactivateWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_watch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherDeleteWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeactivateWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deactivateWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeactivateWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_watch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherDeleteWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     delete_watch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeleteWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    delete_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeleteWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherDeleteWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    delete_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeleteWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    delete_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeleteWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherDeleteWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     deleteWatch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeleteWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherDeleteWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherExecuteWatch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeleteWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    deleteWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherDeleteWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.WatcherExecuteWatchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherExecuteWatch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherExecuteWatch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherExecuteWatch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherExecuteWatchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    execute_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherExecuteWatchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.WatcherExecuteWatchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherExecuteWatch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherExecuteWatch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_watch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherGetWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherExecuteWatchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    executeWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherExecuteWatchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_watch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherGetWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     get_watch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherGetWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    get_watch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherGetWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getWatch<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherGetWatch, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    get_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherGetWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    get_watch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherGetWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getWatch<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherGetWatchRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     getWatch<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherGetWatch, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    getWatch<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherGetWatch, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherPutWatch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    getWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherGetWatchRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    getWatch<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherGetWatchRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.WatcherPutWatchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherPutWatch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherPutWatch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherPutWatch<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherPutWatchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    put_watch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherPutWatchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params?: Req.WatcherPutWatchRequest<TRequestBody>, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherPutWatch<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: RequestParams.WatcherPutWatch<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherStart, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherPutWatchRequest<TRequestBody>, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    putWatch<TResponse = Record<string, any>, TRequestBody extends RequestBody = Record<string, any>, TContext = Context>(params: Req.WatcherPutWatchRequest<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherStartRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     start<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherStart, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    start<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherStart, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherStats, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    start<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherStartRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    start<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherStartRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherStatsRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stats<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherStats, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stats<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherStats, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.WatcherStop, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherStatsRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stats<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherStatsRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params?: Req.WatcherStopRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     stop<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherStop, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    stop<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.WatcherStop, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherStopRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    stop<TResponse = Record<string, any>, TContext = Context>(params: Req.WatcherStopRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   xpack: {
-    info<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.XpackInfo, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params?: Req.XpackInfoRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     info<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.XpackInfo, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    info<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.XpackInfo, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    usage<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.XpackUsage, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
+    info<TResponse = Record<string, any>, TContext = Context>(params: Req.XpackInfoRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    info<TResponse = Record<string, any>, TContext = Context>(params: Req.XpackInfoRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    usage<TResponse = Record<string, any>, TContext = Context>(params?: Req.XpackUsageRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse<TResponse, TContext>>
     usage<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    usage<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.XpackUsage, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
-    usage<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.XpackUsage, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    usage<TResponse = Record<string, any>, TContext = Context>(params: Req.XpackUsageRequest, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
+    usage<TResponse = Record<string, any>, TContext = Context>(params: Req.XpackUsageRequest, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>): TransportRequestCallback
   }
   /* /GENERATED */
 }
@@ -2643,6 +2644,8 @@ declare const events: {
   RESURRECT: string;
 };
 
+export * from './api/RequestTypes'
+export * from './api/ResponseTypes'
 export {
   Client,
   Transport,
@@ -2657,7 +2660,6 @@ export {
   ApiResponse,
   RequestEvent,
   ResurrectEvent,
-  RequestParams,
   ClientOptions,
   NodeOptions,
   ClientExtendsCallbackOptions
diff --git a/lib/Helpers.d.ts b/lib/Helpers.d.ts
index 70af79c60..c6786900a 100644
--- a/lib/Helpers.d.ts
+++ b/lib/Helpers.d.ts
@@ -4,12 +4,12 @@
 
 import { Readable as ReadableStream } from 'stream'
 import { TransportRequestOptions, ApiError, ApiResponse, RequestBody, Context } from './Transport'
-import { Search, Msearch, Bulk } from '../api/requestParams'
+import { SearchRequest, BulkRequest, MsearchRequest } from '../api/RequestTypes'
 
 export default class Helpers {
-  search<TDocument = unknown, TRequestBody extends RequestBody = Record<string, any>>(params: Search<TRequestBody>, options?: TransportRequestOptions): Promise<TDocument[]>
-  scrollSearch<TDocument = unknown, TResponse = Record<string, any>, TRequestBody extends  RequestBody = Record<string, any>, TContext = Context>(params: Search<TRequestBody>, options?: TransportRequestOptions): AsyncIterable<ScrollSearchResponse<TDocument, TResponse, TContext>>
-  scrollDocuments<TDocument = unknown, TRequestBody extends RequestBody = Record<string, any>>(params: Search<TRequestBody>, options?: TransportRequestOptions): AsyncIterable<TDocument>
+  search<TDocument = unknown, TRequestBody extends RequestBody = Record<string, any>>(params: SearchRequest<TRequestBody>, options?: TransportRequestOptions): Promise<TDocument[]>
+  scrollSearch<TDocument = unknown, TResponse = Record<string, any>, TRequestBody extends  RequestBody = Record<string, any>, TContext = Context>(params: SearchRequest<TRequestBody>, options?: TransportRequestOptions): AsyncIterable<ScrollSearchResponse<TDocument, TResponse, TContext>>
+  scrollDocuments<TDocument = unknown, TRequestBody extends RequestBody = Record<string, any>>(params: SearchRequest<TRequestBody>, options?: TransportRequestOptions): AsyncIterable<TDocument>
   msearch(options?: MsearchHelperOptions): MsearchHelper
   bulk<TDocument = unknown>(options: BulkHelperOptions<TDocument>): BulkHelper<BulkStats>
 }
@@ -65,7 +65,7 @@ type UpdateAction = [UpdateActionOperation, Record<string, any>]
 type Action = IndexAction | CreateAction | UpdateAction | DeleteAction
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 
-export interface BulkHelperOptions<TDocument = unknown> extends Omit<Bulk, 'body'> {
+export interface BulkHelperOptions<TDocument = unknown> extends Omit<BulkRequest, 'body'> {
   datasource: TDocument[] | Buffer | ReadableStream | AsyncIterator<TDocument>
   onDocument: (doc: TDocument) => Action
   flushBytes?: number
@@ -91,7 +91,7 @@ export interface OnDropDocument<TDocument = unknown> {
   retried: boolean
 }
 
-export interface MsearchHelperOptions extends Omit<Msearch, 'body'> {
+export interface MsearchHelperOptions extends Omit<MsearchRequest, 'body'> {
   operations?: number
   flushInterval?: number
   concurrency?: number
@@ -102,6 +102,6 @@ export interface MsearchHelperOptions extends Omit<Msearch, 'body'> {
 declare type callbackFn<Response, Context> = (err: ApiError, result: ApiResponse<Response, Context>) => void;
 export interface MsearchHelper extends Promise<void> {
   stop(error?: Error): void
-  search<TResponse = Record<string, any>, TRequestBody extends  RequestBody = Record<string, any>, TContext = Context>(header: Omit<Search, 'body'>, body: TRequestBody): Promise<ApiResponse<TResponse, TContext>>
-  search<TResponse = Record<string, any>, TRequestBody extends  RequestBody = Record<string, any>, TContext = Context>(header: Omit<Search, 'body'>, body: TRequestBody, callback: callbackFn<TResponse, TContext>): void
+  search<TResponse = Record<string, any>, TRequestBody extends  RequestBody = Record<string, any>, TContext = Context>(header: Omit<SearchRequest, 'body'>, body: TRequestBody): Promise<ApiResponse<TResponse, TContext>>
+  search<TResponse = Record<string, any>, TRequestBody extends  RequestBody = Record<string, any>, TContext = Context>(header: Omit<SearchRequest, 'body'>, body: TRequestBody, callback: callbackFn<TResponse, TContext>): void
 }
diff --git a/scripts/generate.js b/scripts/generate.js
index e1c011303..03c82a5f6 100644
--- a/scripts/generate.js
+++ b/scripts/generate.js
@@ -35,7 +35,7 @@ function start (opts) {
   const typeDefFile = join(__dirname, '..', 'index.d.ts')
   const kibanaTypeDefFile = join(packageFolder, 'kibana.d.ts')
   const docOutputFile = join(__dirname, '..', 'docs', 'reference.asciidoc')
-  const requestParamsOutputFile = join(packageFolder, 'requestParams.d.ts')
+  const requestParamsOutputFile = join(packageFolder, 'RequestTypes.d.ts')
   const allSpec = []
 
   log.text = 'Cleaning API folder...'
diff --git a/scripts/utils/generateMain.js b/scripts/utils/generateMain.js
index f3223688a..1d8c0f33e 100644
--- a/scripts/utils/generateMain.js
+++ b/scripts/utils/generateMain.js
@@ -12,6 +12,17 @@ const dedent = require('dedent')
 const deepmerge = require('deepmerge')
 const { ndjsonApi } = require('./generateApis')
 
+const supportedResponses = [
+  'Search',
+  'MSearch',
+  'Create',
+  'Index',
+  'Delete',
+  'Update',
+  'Get',
+  'Bulk'
+]
+
 const ndjsonApiKey = ndjsonApi
   .map(api => {
     return api
@@ -220,48 +231,49 @@ function buildMethodDefinition (opts, api, name, hasBody) {
   const Name = toPascalCase(name)
   const bodyType = ndjsonApiKey.includes(Name) ? 'RequestNDBody' : 'RequestBody'
   const defaultBodyType = ndjsonApiKey.includes(Name) ? 'Record<string, any>[]' : 'Record<string, any>'
+  const responseType = supportedResponses.includes(Name) ? `Res.${Name}Response` : 'Record<string, any>'
 
   if (opts.kibana) {
     if (hasBody) {
       return [
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params?: RequestParams.${Name}<TRequestBody>, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` }
+        { key: `${camelify(api)}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params?: Req.${Name}Request<TRequestBody>, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` }
       ]
     } else {
       return [
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.${Name}, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` }
+        { key: `${camelify(api)}<TResponse = Record<string, any>, TContext = Context>(params?: Req.${Name}Request, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` }
       ]
     }
   }
 
   if (hasBody) {
     let methods = [
-      { key: `${api}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params?: RequestParams.${Name}<TRequestBody>, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
-      { key: `${api}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-      { key: `${api}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: RequestParams.${Name}<TRequestBody>, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-      { key: `${api}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: RequestParams.${Name}<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
+      { key: `${api}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params?: Req.${Name}Request<TRequestBody>, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
+      { key: `${api}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+      { key: `${api}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: Req.${Name}Request<TRequestBody>, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+      { key: `${api}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: Req.${Name}Request<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
     ]
     if (isSnakeCased(api)) {
       methods = methods.concat([
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params?: RequestParams.${Name}<TRequestBody>, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: RequestParams.${Name}<TRequestBody>, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: RequestParams.${Name}<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
+        { key: `${camelify(api)}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params?: Req.${Name}Request<TRequestBody>, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
+        { key: `${camelify(api)}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+        { key: `${camelify(api)}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: Req.${Name}Request<TRequestBody>, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+        { key: `${camelify(api)}<TResponse = ${responseType}, TRequestBody extends ${bodyType} = ${defaultBodyType}, TContext = Context>(params: Req.${Name}Request<TRequestBody>, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
       ])
     }
     return methods
   } else {
     let methods = [
-      { key: `${api}<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.${Name}, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
-      { key: `${api}<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-      { key: `${api}<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.${Name}, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-      { key: `${api}<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.${Name}, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
+      { key: `${api}<TResponse = ${responseType}, TContext = Context>(params?: Req.${Name}Request, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
+      { key: `${api}<TResponse = ${responseType}, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+      { key: `${api}<TResponse = ${responseType}, TContext = Context>(params: Req.${Name}Request, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+      { key: `${api}<TResponse = ${responseType}, TContext = Context>(params: Req.${Name}Request, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
     ]
     if (isSnakeCased(api)) {
       methods = methods.concat([
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TContext = Context>(params?: RequestParams.${Name}, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.${Name}, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
-        { key: `${camelify(api)}<TResponse = Record<string, any>, TContext = Context>(params: RequestParams.${Name}, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
+        { key: `${camelify(api)}<TResponse = ${responseType}, TContext = Context>(params?: Req.${Name}Request, options?: TransportRequestOptions)`, val: `TransportRequestPromise<ApiResponse<TResponse, TContext>>` },
+        { key: `${camelify(api)}<TResponse = ${responseType}, TContext = Context>(callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+        { key: `${camelify(api)}<TResponse = ${responseType}, TContext = Context>(params: Req.${Name}Request, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` },
+        { key: `${camelify(api)}<TResponse = ${responseType}, TContext = Context>(params: Req.${Name}Request, options: TransportRequestOptions, callback: callbackFn<TResponse, TContext>)`, val: `TransportRequestCallback` }
       ])
     }
     return methods
diff --git a/scripts/utils/generateRequestTypes.js b/scripts/utils/generateRequestTypes.js
index 4e4f389b2..58ac19f6b 100644
--- a/scripts/utils/generateRequestTypes.js
+++ b/scripts/utils/generateRequestTypes.js
@@ -17,6 +17,7 @@ const ndjsonApiKey = ndjsonApi
   .map(toPascalCase)
 
 function generate (version, api) {
+  var exportNewLineCount = 0
   const release = semver.valid(version) ? semver.major(version) : version
   var types = `// Licensed to Elasticsearch B.V under one or more agreements.
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
@@ -24,7 +25,7 @@ function generate (version, api) {
 
 import { RequestBody, RequestNDBody } from '../lib/Transport'
 
-export interface Generic {
+interface GenericRequest {
   method?: string;
   filter_path?: string | string[];
   pretty?: boolean;
@@ -35,6 +36,11 @@ export interface Generic {
 `
 
   api.forEach(generateRequestType)
+  types += '\nexport {\n'
+  api.forEach(generateExport)
+  // removes last comma
+  types = types.slice(0, -2) + '\n'
+  types += '}'
   return types
 
   function generateRequestType (spec) {
@@ -96,7 +102,7 @@ export interface Generic {
     const bodyGeneric = ndjsonApiKey.includes(toPascalCase(name)) ? 'RequestNDBody' : 'RequestBody'
 
     const code = `
-export interface ${toPascalCase(name)}${body ? `<T = ${bodyGeneric}>` : ''} extends Generic {
+interface ${toPascalCase(name)}Request${body ? `<T = ${bodyGeneric}>` : ''} extends GenericRequest {
   ${partsArr.map(genLine).join('\n  ')}
   ${paramsArr.map(genLine).join('\n  ')}
   ${body ? `body${body.required ? '' : '?'}: T;` : ''}
@@ -152,6 +158,18 @@ export interface ${toPascalCase(name)}${body ? `<T = ${bodyGeneric}>` : ''} exte
         return type
     }
   }
+
+  function generateExport (spec) {
+    const api = Object.keys(spec)[0]
+    const name = api
+      .replace(/\.([a-z])/g, k => k[1].toUpperCase())
+      .replace(/_([a-z])/g, k => k[1].toUpperCase())
+    types += exportNewLineCount === 0 ? '  ' : ''
+    types += toPascalCase(name) + 'Request,'
+    types += exportNewLineCount < 3 ? ' ' : '\n'
+    exportNewLineCount += 1
+    if (exportNewLineCount > 3) exportNewLineCount = 0
+  }
 }
 
 function intersect (first, ...rest) {
diff --git a/test/types/api-response-body.test-d.ts b/test/types/api-response-body.test-d.ts
index 6a20beb27..7181b5bcc 100644
--- a/test/types/api-response-body.test-d.ts
+++ b/test/types/api-response-body.test-d.ts
@@ -5,7 +5,7 @@
 import { expectType, expectError } from 'tsd'
 import { Readable as ReadableStream } from 'stream';
 import { TransportRequestCallback, Context } from '../../lib/Transport'
-import { Client, ApiError } from '../../'
+import { Client, ApiError, SearchResponse } from '../../'
 
 const client = new Client({
   node: 'http://localhost:9200'
@@ -17,45 +17,6 @@ interface SearchBody {
   }
 }
 
-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
 }
@@ -79,7 +40,7 @@ expectError(
     }
   })
 
-  expectType<Record<string, any>>(response.body)
+  expectType<SearchResponse>(response.body)
   expectType<Context>(response.meta.context)
 }
 
@@ -135,7 +96,7 @@ expectError(
     body: 'hello world'
   })
 
-  expectType<Record<string, any>>(response.body)
+  expectType<SearchResponse>(response.body)
   expectType<Context>(response.meta.context)
 }
 
@@ -146,7 +107,7 @@ expectError(
     body: Buffer.from('hello world')
   })
 
-  expectType<Record<string, any>>(response.body)
+  expectType<SearchResponse>(response.body)
   expectType<Context>(response.meta.context)
 }
 
@@ -157,7 +118,7 @@ expectError(
     body: new ReadableStream()
   })
 
-  expectType<Record<string, any>>(response.body)
+  expectType<SearchResponse>(response.body)
   expectType<Context>(response.meta.context)
 }
 
@@ -172,7 +133,7 @@ expectError(
     }
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
+    expectType<SearchResponse>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
@@ -236,7 +197,7 @@ expectError(
     body: 'hello world'
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
+    expectType<SearchResponse>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
@@ -249,7 +210,7 @@ expectError(
     body: Buffer.from('hello world')
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
+    expectType<SearchResponse>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)
@@ -262,7 +223,7 @@ expectError(
     body: new ReadableStream()
   }, (err, response) => {
     expectType<ApiError>(err)
-    expectType<Record<string, any>>(response.body)
+    expectType<SearchResponse>(response.body)
     expectType<Context>(response.meta.context)
   })
   expectType<TransportRequestCallback>(result)