From 81c51e934f2262a7c7c7efab68ac6dfbceba2e29 Mon Sep 17 00:00:00 2001
From: "opensearch-trigger-bot[bot]"
 <98922864+opensearch-trigger-bot[bot]@users.noreply.github.com>
Date: Mon, 30 Sep 2024 09:51:26 -0600
Subject: [PATCH] [AUTOCUT] Update opensearch-js to reflect the latest
 OpenSearch API spec (#881)

Co-authored-by: nhtruong <644650+nhtruong@users.noreply.github.com>
---
 api/OpenSearchApi.d.ts          | 1627 +++++++++++++++++++++++++++++++
 api/OpenSearchApi.js            |  187 ++++
 api/_types/_common.d.ts         |    2 +
 api/_types/_common.mapping.d.ts |    4 +
 api/knn/trainModel.d.ts         |    9 +-
 5 files changed, 1827 insertions(+), 2 deletions(-)
 create mode 100644 api/OpenSearchApi.d.ts
 create mode 100644 api/OpenSearchApi.js

diff --git a/api/OpenSearchApi.d.ts b/api/OpenSearchApi.d.ts
new file mode 100644
index 000000000..b735dafc8
--- /dev/null
+++ b/api/OpenSearchApi.d.ts
@@ -0,0 +1,1627 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ */
+
+/*
+ * This file was generated from the OpenSearch API Spec. Do NOT edit it
+ * manually. If you want to make changes, either update the spec or
+ * modify the API generator.
+ */
+
+import * as Global from './_types/_global';
+import * as API from './index';
+import {
+  ApiError,
+  ApiResponse,
+  TransportRequestOptions,
+  TransportRequestCallback,
+  TransportRequestPromise,
+} from '../lib/Transport';
+
+declare type callbackFn<TResponse> = (err: ApiError, result: TResponse) => void;
+
+declare interface HttpRequest {
+  path: string;
+  querystring?: Global.Params;
+  headers?: Record<string, any>;
+  body?: Record<string, any> | Record<string, any>[] | string;
+}
+
+export default class OpenSearchAPI {
+  asynchronousSearch: {
+    search (params?: API.AsynchronousSearch_Search_Request, options?: TransportRequestOptions): TransportRequestPromise<API.AsynchronousSearch_Search_Response>;
+    search (callback: callbackFn<API.AsynchronousSearch_Search_Response>): TransportRequestCallback;
+    search (params: API.AsynchronousSearch_Search_Request, callback: callbackFn<API.AsynchronousSearch_Search_Response>): TransportRequestCallback;
+    search (params: API.AsynchronousSearch_Search_Request, options: TransportRequestOptions, callback: callbackFn<API.AsynchronousSearch_Search_Response>): TransportRequestCallback;
+
+    delete (params: API.AsynchronousSearch_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.AsynchronousSearch_Delete_Response>;
+    delete (params: API.AsynchronousSearch_Delete_Request, callback: callbackFn<API.AsynchronousSearch_Delete_Response>): TransportRequestCallback;
+    delete (params: API.AsynchronousSearch_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.AsynchronousSearch_Delete_Response>): TransportRequestCallback;
+
+    get (params: API.AsynchronousSearch_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.AsynchronousSearch_Get_Response>;
+    get (params: API.AsynchronousSearch_Get_Request, callback: callbackFn<API.AsynchronousSearch_Get_Response>): TransportRequestCallback;
+    get (params: API.AsynchronousSearch_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.AsynchronousSearch_Get_Response>): TransportRequestCallback;
+
+    stats (params?: API.AsynchronousSearch_Stats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.AsynchronousSearch_Stats_Response>;
+    stats (callback: callbackFn<API.AsynchronousSearch_Stats_Response>): TransportRequestCallback;
+    stats (params: API.AsynchronousSearch_Stats_Request, callback: callbackFn<API.AsynchronousSearch_Stats_Response>): TransportRequestCallback;
+    stats (params: API.AsynchronousSearch_Stats_Request, options: TransportRequestOptions, callback: callbackFn<API.AsynchronousSearch_Stats_Response>): TransportRequestCallback;
+
+  };
+
+  cat: {
+    help (params?: API.Cat_Help_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Help_Response>;
+    help (callback: callbackFn<API.Cat_Help_Response>): TransportRequestCallback;
+    help (params: API.Cat_Help_Request, callback: callbackFn<API.Cat_Help_Response>): TransportRequestCallback;
+    help (params: API.Cat_Help_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Help_Response>): TransportRequestCallback;
+
+    aliases (params?: API.Cat_Aliases_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Aliases_Response>;
+    aliases (callback: callbackFn<API.Cat_Aliases_Response>): TransportRequestCallback;
+    aliases (params: API.Cat_Aliases_Request, callback: callbackFn<API.Cat_Aliases_Response>): TransportRequestCallback;
+    aliases (params: API.Cat_Aliases_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Aliases_Response>): TransportRequestCallback;
+
+    allocation (params?: API.Cat_Allocation_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Allocation_Response>;
+    allocation (callback: callbackFn<API.Cat_Allocation_Response>): TransportRequestCallback;
+    allocation (params: API.Cat_Allocation_Request, callback: callbackFn<API.Cat_Allocation_Response>): TransportRequestCallback;
+    allocation (params: API.Cat_Allocation_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Allocation_Response>): TransportRequestCallback;
+
+    clusterManager (params?: API.Cat_ClusterManager_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_ClusterManager_Response>;
+    clusterManager (callback: callbackFn<API.Cat_ClusterManager_Response>): TransportRequestCallback;
+    clusterManager (params: API.Cat_ClusterManager_Request, callback: callbackFn<API.Cat_ClusterManager_Response>): TransportRequestCallback;
+    clusterManager (params: API.Cat_ClusterManager_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_ClusterManager_Response>): TransportRequestCallback;
+
+    count (params?: API.Cat_Count_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Count_Response>;
+    count (callback: callbackFn<API.Cat_Count_Response>): TransportRequestCallback;
+    count (params: API.Cat_Count_Request, callback: callbackFn<API.Cat_Count_Response>): TransportRequestCallback;
+    count (params: API.Cat_Count_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Count_Response>): TransportRequestCallback;
+
+    fielddata (params?: API.Cat_Fielddata_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Fielddata_Response>;
+    fielddata (callback: callbackFn<API.Cat_Fielddata_Response>): TransportRequestCallback;
+    fielddata (params: API.Cat_Fielddata_Request, callback: callbackFn<API.Cat_Fielddata_Response>): TransportRequestCallback;
+    fielddata (params: API.Cat_Fielddata_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Fielddata_Response>): TransportRequestCallback;
+
+    health (params?: API.Cat_Health_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Health_Response>;
+    health (callback: callbackFn<API.Cat_Health_Response>): TransportRequestCallback;
+    health (params: API.Cat_Health_Request, callback: callbackFn<API.Cat_Health_Response>): TransportRequestCallback;
+    health (params: API.Cat_Health_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Health_Response>): TransportRequestCallback;
+
+    indices (params?: API.Cat_Indices_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Indices_Response>;
+    indices (callback: callbackFn<API.Cat_Indices_Response>): TransportRequestCallback;
+    indices (params: API.Cat_Indices_Request, callback: callbackFn<API.Cat_Indices_Response>): TransportRequestCallback;
+    indices (params: API.Cat_Indices_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Indices_Response>): TransportRequestCallback;
+
+    master (params?: API.Cat_Master_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Master_Response>;
+    master (callback: callbackFn<API.Cat_Master_Response>): TransportRequestCallback;
+    master (params: API.Cat_Master_Request, callback: callbackFn<API.Cat_Master_Response>): TransportRequestCallback;
+    master (params: API.Cat_Master_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Master_Response>): TransportRequestCallback;
+
+    nodeattrs (params?: API.Cat_Nodeattrs_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Nodeattrs_Response>;
+    nodeattrs (callback: callbackFn<API.Cat_Nodeattrs_Response>): TransportRequestCallback;
+    nodeattrs (params: API.Cat_Nodeattrs_Request, callback: callbackFn<API.Cat_Nodeattrs_Response>): TransportRequestCallback;
+    nodeattrs (params: API.Cat_Nodeattrs_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Nodeattrs_Response>): TransportRequestCallback;
+
+    nodes (params?: API.Cat_Nodes_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Nodes_Response>;
+    nodes (callback: callbackFn<API.Cat_Nodes_Response>): TransportRequestCallback;
+    nodes (params: API.Cat_Nodes_Request, callback: callbackFn<API.Cat_Nodes_Response>): TransportRequestCallback;
+    nodes (params: API.Cat_Nodes_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Nodes_Response>): TransportRequestCallback;
+
+    pendingTasks (params?: API.Cat_PendingTasks_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_PendingTasks_Response>;
+    pendingTasks (callback: callbackFn<API.Cat_PendingTasks_Response>): TransportRequestCallback;
+    pendingTasks (params: API.Cat_PendingTasks_Request, callback: callbackFn<API.Cat_PendingTasks_Response>): TransportRequestCallback;
+    pendingTasks (params: API.Cat_PendingTasks_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_PendingTasks_Response>): TransportRequestCallback;
+
+    pitSegments (params?: API.Cat_PitSegments_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_PitSegments_Response>;
+    pitSegments (callback: callbackFn<API.Cat_PitSegments_Response>): TransportRequestCallback;
+    pitSegments (params: API.Cat_PitSegments_Request, callback: callbackFn<API.Cat_PitSegments_Response>): TransportRequestCallback;
+    pitSegments (params: API.Cat_PitSegments_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_PitSegments_Response>): TransportRequestCallback;
+
+    allPitSegments (params?: API.Cat_AllPitSegments_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_AllPitSegments_Response>;
+    allPitSegments (callback: callbackFn<API.Cat_AllPitSegments_Response>): TransportRequestCallback;
+    allPitSegments (params: API.Cat_AllPitSegments_Request, callback: callbackFn<API.Cat_AllPitSegments_Response>): TransportRequestCallback;
+    allPitSegments (params: API.Cat_AllPitSegments_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_AllPitSegments_Response>): TransportRequestCallback;
+
+    plugins (params?: API.Cat_Plugins_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Plugins_Response>;
+    plugins (callback: callbackFn<API.Cat_Plugins_Response>): TransportRequestCallback;
+    plugins (params: API.Cat_Plugins_Request, callback: callbackFn<API.Cat_Plugins_Response>): TransportRequestCallback;
+    plugins (params: API.Cat_Plugins_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Plugins_Response>): TransportRequestCallback;
+
+    recovery (params?: API.Cat_Recovery_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Recovery_Response>;
+    recovery (callback: callbackFn<API.Cat_Recovery_Response>): TransportRequestCallback;
+    recovery (params: API.Cat_Recovery_Request, callback: callbackFn<API.Cat_Recovery_Response>): TransportRequestCallback;
+    recovery (params: API.Cat_Recovery_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Recovery_Response>): TransportRequestCallback;
+
+    repositories (params?: API.Cat_Repositories_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Repositories_Response>;
+    repositories (callback: callbackFn<API.Cat_Repositories_Response>): TransportRequestCallback;
+    repositories (params: API.Cat_Repositories_Request, callback: callbackFn<API.Cat_Repositories_Response>): TransportRequestCallback;
+    repositories (params: API.Cat_Repositories_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Repositories_Response>): TransportRequestCallback;
+
+    segmentReplication (params?: API.Cat_SegmentReplication_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_SegmentReplication_Response>;
+    segmentReplication (callback: callbackFn<API.Cat_SegmentReplication_Response>): TransportRequestCallback;
+    segmentReplication (params: API.Cat_SegmentReplication_Request, callback: callbackFn<API.Cat_SegmentReplication_Response>): TransportRequestCallback;
+    segmentReplication (params: API.Cat_SegmentReplication_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_SegmentReplication_Response>): TransportRequestCallback;
+
+    segments (params?: API.Cat_Segments_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Segments_Response>;
+    segments (callback: callbackFn<API.Cat_Segments_Response>): TransportRequestCallback;
+    segments (params: API.Cat_Segments_Request, callback: callbackFn<API.Cat_Segments_Response>): TransportRequestCallback;
+    segments (params: API.Cat_Segments_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Segments_Response>): TransportRequestCallback;
+
+    shards (params?: API.Cat_Shards_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Shards_Response>;
+    shards (callback: callbackFn<API.Cat_Shards_Response>): TransportRequestCallback;
+    shards (params: API.Cat_Shards_Request, callback: callbackFn<API.Cat_Shards_Response>): TransportRequestCallback;
+    shards (params: API.Cat_Shards_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Shards_Response>): TransportRequestCallback;
+
+    snapshots (params?: API.Cat_Snapshots_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Snapshots_Response>;
+    snapshots (callback: callbackFn<API.Cat_Snapshots_Response>): TransportRequestCallback;
+    snapshots (params: API.Cat_Snapshots_Request, callback: callbackFn<API.Cat_Snapshots_Response>): TransportRequestCallback;
+    snapshots (params: API.Cat_Snapshots_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Snapshots_Response>): TransportRequestCallback;
+
+    tasks (params?: API.Cat_Tasks_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Tasks_Response>;
+    tasks (callback: callbackFn<API.Cat_Tasks_Response>): TransportRequestCallback;
+    tasks (params: API.Cat_Tasks_Request, callback: callbackFn<API.Cat_Tasks_Response>): TransportRequestCallback;
+    tasks (params: API.Cat_Tasks_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Tasks_Response>): TransportRequestCallback;
+
+    templates (params?: API.Cat_Templates_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_Templates_Response>;
+    templates (callback: callbackFn<API.Cat_Templates_Response>): TransportRequestCallback;
+    templates (params: API.Cat_Templates_Request, callback: callbackFn<API.Cat_Templates_Response>): TransportRequestCallback;
+    templates (params: API.Cat_Templates_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_Templates_Response>): TransportRequestCallback;
+
+    threadPool (params?: API.Cat_ThreadPool_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cat_ThreadPool_Response>;
+    threadPool (callback: callbackFn<API.Cat_ThreadPool_Response>): TransportRequestCallback;
+    threadPool (params: API.Cat_ThreadPool_Request, callback: callbackFn<API.Cat_ThreadPool_Response>): TransportRequestCallback;
+    threadPool (params: API.Cat_ThreadPool_Request, options: TransportRequestOptions, callback: callbackFn<API.Cat_ThreadPool_Response>): TransportRequestCallback;
+
+  };
+
+  cluster: {
+    allocationExplain (params?: API.Cluster_AllocationExplain_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_AllocationExplain_Response>;
+    allocationExplain (callback: callbackFn<API.Cluster_AllocationExplain_Response>): TransportRequestCallback;
+    allocationExplain (params: API.Cluster_AllocationExplain_Request, callback: callbackFn<API.Cluster_AllocationExplain_Response>): TransportRequestCallback;
+    allocationExplain (params: API.Cluster_AllocationExplain_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_AllocationExplain_Response>): TransportRequestCallback;
+
+    deleteDecommissionAwareness (params?: API.Cluster_DeleteDecommissionAwareness_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_DeleteDecommissionAwareness_Response>;
+    deleteDecommissionAwareness (callback: callbackFn<API.Cluster_DeleteDecommissionAwareness_Response>): TransportRequestCallback;
+    deleteDecommissionAwareness (params: API.Cluster_DeleteDecommissionAwareness_Request, callback: callbackFn<API.Cluster_DeleteDecommissionAwareness_Response>): TransportRequestCallback;
+    deleteDecommissionAwareness (params: API.Cluster_DeleteDecommissionAwareness_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_DeleteDecommissionAwareness_Response>): TransportRequestCallback;
+
+    getDecommissionAwareness (params: API.Cluster_GetDecommissionAwareness_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_GetDecommissionAwareness_Response>;
+    getDecommissionAwareness (params: API.Cluster_GetDecommissionAwareness_Request, callback: callbackFn<API.Cluster_GetDecommissionAwareness_Response>): TransportRequestCallback;
+    getDecommissionAwareness (params: API.Cluster_GetDecommissionAwareness_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_GetDecommissionAwareness_Response>): TransportRequestCallback;
+
+    putDecommissionAwareness (params: API.Cluster_PutDecommissionAwareness_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_PutDecommissionAwareness_Response>;
+    putDecommissionAwareness (params: API.Cluster_PutDecommissionAwareness_Request, callback: callbackFn<API.Cluster_PutDecommissionAwareness_Response>): TransportRequestCallback;
+    putDecommissionAwareness (params: API.Cluster_PutDecommissionAwareness_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_PutDecommissionAwareness_Response>): TransportRequestCallback;
+
+    health (params?: API.Cluster_Health_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_Health_Response>;
+    health (callback: callbackFn<API.Cluster_Health_Response>): TransportRequestCallback;
+    health (params: API.Cluster_Health_Request, callback: callbackFn<API.Cluster_Health_Response>): TransportRequestCallback;
+    health (params: API.Cluster_Health_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_Health_Response>): TransportRequestCallback;
+
+    pendingTasks (params?: API.Cluster_PendingTasks_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_PendingTasks_Response>;
+    pendingTasks (callback: callbackFn<API.Cluster_PendingTasks_Response>): TransportRequestCallback;
+    pendingTasks (params: API.Cluster_PendingTasks_Request, callback: callbackFn<API.Cluster_PendingTasks_Response>): TransportRequestCallback;
+    pendingTasks (params: API.Cluster_PendingTasks_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_PendingTasks_Response>): TransportRequestCallback;
+
+    reroute (params?: API.Cluster_Reroute_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_Reroute_Response>;
+    reroute (callback: callbackFn<API.Cluster_Reroute_Response>): TransportRequestCallback;
+    reroute (params: API.Cluster_Reroute_Request, callback: callbackFn<API.Cluster_Reroute_Response>): TransportRequestCallback;
+    reroute (params: API.Cluster_Reroute_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_Reroute_Response>): TransportRequestCallback;
+
+    getWeightedRouting (params: API.Cluster_GetWeightedRouting_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_GetWeightedRouting_Response>;
+    getWeightedRouting (params: API.Cluster_GetWeightedRouting_Request, callback: callbackFn<API.Cluster_GetWeightedRouting_Response>): TransportRequestCallback;
+    getWeightedRouting (params: API.Cluster_GetWeightedRouting_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_GetWeightedRouting_Response>): TransportRequestCallback;
+
+    putWeightedRouting (params: API.Cluster_PutWeightedRouting_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_PutWeightedRouting_Response>;
+    putWeightedRouting (params: API.Cluster_PutWeightedRouting_Request, callback: callbackFn<API.Cluster_PutWeightedRouting_Response>): TransportRequestCallback;
+    putWeightedRouting (params: API.Cluster_PutWeightedRouting_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_PutWeightedRouting_Response>): TransportRequestCallback;
+
+    deleteWeightedRouting (params?: API.Cluster_DeleteWeightedRouting_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_DeleteWeightedRouting_Response>;
+    deleteWeightedRouting (callback: callbackFn<API.Cluster_DeleteWeightedRouting_Response>): TransportRequestCallback;
+    deleteWeightedRouting (params: API.Cluster_DeleteWeightedRouting_Request, callback: callbackFn<API.Cluster_DeleteWeightedRouting_Response>): TransportRequestCallback;
+    deleteWeightedRouting (params: API.Cluster_DeleteWeightedRouting_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_DeleteWeightedRouting_Response>): TransportRequestCallback;
+
+    getSettings (params?: API.Cluster_GetSettings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_GetSettings_Response>;
+    getSettings (callback: callbackFn<API.Cluster_GetSettings_Response>): TransportRequestCallback;
+    getSettings (params: API.Cluster_GetSettings_Request, callback: callbackFn<API.Cluster_GetSettings_Response>): TransportRequestCallback;
+    getSettings (params: API.Cluster_GetSettings_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_GetSettings_Response>): TransportRequestCallback;
+
+    putSettings (params: API.Cluster_PutSettings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_PutSettings_Response>;
+    putSettings (params: API.Cluster_PutSettings_Request, callback: callbackFn<API.Cluster_PutSettings_Response>): TransportRequestCallback;
+    putSettings (params: API.Cluster_PutSettings_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_PutSettings_Response>): TransportRequestCallback;
+
+    state (params?: API.Cluster_State_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_State_Response>;
+    state (callback: callbackFn<API.Cluster_State_Response>): TransportRequestCallback;
+    state (params: API.Cluster_State_Request, callback: callbackFn<API.Cluster_State_Response>): TransportRequestCallback;
+    state (params: API.Cluster_State_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_State_Response>): TransportRequestCallback;
+
+    stats (params?: API.Cluster_Stats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_Stats_Response>;
+    stats (callback: callbackFn<API.Cluster_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Cluster_Stats_Request, callback: callbackFn<API.Cluster_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Cluster_Stats_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_Stats_Response>): TransportRequestCallback;
+
+    deleteVotingConfigExclusions (params?: API.Cluster_DeleteVotingConfigExclusions_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_DeleteVotingConfigExclusions_Response>;
+    deleteVotingConfigExclusions (callback: callbackFn<API.Cluster_DeleteVotingConfigExclusions_Response>): TransportRequestCallback;
+    deleteVotingConfigExclusions (params: API.Cluster_DeleteVotingConfigExclusions_Request, callback: callbackFn<API.Cluster_DeleteVotingConfigExclusions_Response>): TransportRequestCallback;
+    deleteVotingConfigExclusions (params: API.Cluster_DeleteVotingConfigExclusions_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_DeleteVotingConfigExclusions_Response>): TransportRequestCallback;
+
+    postVotingConfigExclusions (params?: API.Cluster_PostVotingConfigExclusions_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_PostVotingConfigExclusions_Response>;
+    postVotingConfigExclusions (callback: callbackFn<API.Cluster_PostVotingConfigExclusions_Response>): TransportRequestCallback;
+    postVotingConfigExclusions (params: API.Cluster_PostVotingConfigExclusions_Request, callback: callbackFn<API.Cluster_PostVotingConfigExclusions_Response>): TransportRequestCallback;
+    postVotingConfigExclusions (params: API.Cluster_PostVotingConfigExclusions_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_PostVotingConfigExclusions_Response>): TransportRequestCallback;
+
+    getComponentTemplate (params?: API.Cluster_GetComponentTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_GetComponentTemplate_Response>;
+    getComponentTemplate (callback: callbackFn<API.Cluster_GetComponentTemplate_Response>): TransportRequestCallback;
+    getComponentTemplate (params: API.Cluster_GetComponentTemplate_Request, callback: callbackFn<API.Cluster_GetComponentTemplate_Response>): TransportRequestCallback;
+    getComponentTemplate (params: API.Cluster_GetComponentTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_GetComponentTemplate_Response>): TransportRequestCallback;
+
+    deleteComponentTemplate (params: API.Cluster_DeleteComponentTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_DeleteComponentTemplate_Response>;
+    deleteComponentTemplate (params: API.Cluster_DeleteComponentTemplate_Request, callback: callbackFn<API.Cluster_DeleteComponentTemplate_Response>): TransportRequestCallback;
+    deleteComponentTemplate (params: API.Cluster_DeleteComponentTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_DeleteComponentTemplate_Response>): TransportRequestCallback;
+
+    existsComponentTemplate (params: API.Cluster_ExistsComponentTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_ExistsComponentTemplate_Response>;
+    existsComponentTemplate (params: API.Cluster_ExistsComponentTemplate_Request, callback: callbackFn<API.Cluster_ExistsComponentTemplate_Response>): TransportRequestCallback;
+    existsComponentTemplate (params: API.Cluster_ExistsComponentTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_ExistsComponentTemplate_Response>): TransportRequestCallback;
+
+    putComponentTemplate (params: API.Cluster_PutComponentTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_PutComponentTemplate_Response>;
+    putComponentTemplate (params: API.Cluster_PutComponentTemplate_Request, callback: callbackFn<API.Cluster_PutComponentTemplate_Response>): TransportRequestCallback;
+    putComponentTemplate (params: API.Cluster_PutComponentTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_PutComponentTemplate_Response>): TransportRequestCallback;
+
+    remoteInfo (params?: API.Cluster_RemoteInfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Cluster_RemoteInfo_Response>;
+    remoteInfo (callback: callbackFn<API.Cluster_RemoteInfo_Response>): TransportRequestCallback;
+    remoteInfo (params: API.Cluster_RemoteInfo_Request, callback: callbackFn<API.Cluster_RemoteInfo_Response>): TransportRequestCallback;
+    remoteInfo (params: API.Cluster_RemoteInfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Cluster_RemoteInfo_Response>): TransportRequestCallback;
+
+  };
+
+  danglingIndices: {
+    listDanglingIndices (params?: API.DanglingIndices_ListDanglingIndices_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DanglingIndices_ListDanglingIndices_Response>;
+    listDanglingIndices (callback: callbackFn<API.DanglingIndices_ListDanglingIndices_Response>): TransportRequestCallback;
+    listDanglingIndices (params: API.DanglingIndices_ListDanglingIndices_Request, callback: callbackFn<API.DanglingIndices_ListDanglingIndices_Response>): TransportRequestCallback;
+    listDanglingIndices (params: API.DanglingIndices_ListDanglingIndices_Request, options: TransportRequestOptions, callback: callbackFn<API.DanglingIndices_ListDanglingIndices_Response>): TransportRequestCallback;
+
+    deleteDanglingIndex (params: API.DanglingIndices_DeleteDanglingIndex_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DanglingIndices_DeleteDanglingIndex_Response>;
+    deleteDanglingIndex (params: API.DanglingIndices_DeleteDanglingIndex_Request, callback: callbackFn<API.DanglingIndices_DeleteDanglingIndex_Response>): TransportRequestCallback;
+    deleteDanglingIndex (params: API.DanglingIndices_DeleteDanglingIndex_Request, options: TransportRequestOptions, callback: callbackFn<API.DanglingIndices_DeleteDanglingIndex_Response>): TransportRequestCallback;
+
+    importDanglingIndex (params: API.DanglingIndices_ImportDanglingIndex_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DanglingIndices_ImportDanglingIndex_Response>;
+    importDanglingIndex (params: API.DanglingIndices_ImportDanglingIndex_Request, callback: callbackFn<API.DanglingIndices_ImportDanglingIndex_Response>): TransportRequestCallback;
+    importDanglingIndex (params: API.DanglingIndices_ImportDanglingIndex_Request, options: TransportRequestOptions, callback: callbackFn<API.DanglingIndices_ImportDanglingIndex_Response>): TransportRequestCallback;
+
+  };
+
+  flowFramework: {
+    create (params?: API.FlowFramework_Create_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Create_Response>;
+    create (callback: callbackFn<API.FlowFramework_Create_Response>): TransportRequestCallback;
+    create (params: API.FlowFramework_Create_Request, callback: callbackFn<API.FlowFramework_Create_Response>): TransportRequestCallback;
+    create (params: API.FlowFramework_Create_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Create_Response>): TransportRequestCallback;
+
+    search (params: API.FlowFramework_Search_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Search_Response>;
+    search (params: API.FlowFramework_Search_Request, callback: callbackFn<API.FlowFramework_Search_Response>): TransportRequestCallback;
+    search (params: API.FlowFramework_Search_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Search_Response>): TransportRequestCallback;
+
+    getSteps (params?: API.FlowFramework_GetSteps_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_GetSteps_Response>;
+    getSteps (callback: callbackFn<API.FlowFramework_GetSteps_Response>): TransportRequestCallback;
+    getSteps (params: API.FlowFramework_GetSteps_Request, callback: callbackFn<API.FlowFramework_GetSteps_Response>): TransportRequestCallback;
+    getSteps (params: API.FlowFramework_GetSteps_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_GetSteps_Response>): TransportRequestCallback;
+
+    delete (params: API.FlowFramework_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Delete_Response>;
+    delete (params: API.FlowFramework_Delete_Request, callback: callbackFn<API.FlowFramework_Delete_Response>): TransportRequestCallback;
+    delete (params: API.FlowFramework_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Delete_Response>): TransportRequestCallback;
+
+    get (params: API.FlowFramework_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Get_Response>;
+    get (params: API.FlowFramework_Get_Request, callback: callbackFn<API.FlowFramework_Get_Response>): TransportRequestCallback;
+    get (params: API.FlowFramework_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Get_Response>): TransportRequestCallback;
+
+    update (params: API.FlowFramework_Update_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Update_Response>;
+    update (params: API.FlowFramework_Update_Request, callback: callbackFn<API.FlowFramework_Update_Response>): TransportRequestCallback;
+    update (params: API.FlowFramework_Update_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Update_Response>): TransportRequestCallback;
+
+    deprovision (params: API.FlowFramework_Deprovision_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Deprovision_Response>;
+    deprovision (params: API.FlowFramework_Deprovision_Request, callback: callbackFn<API.FlowFramework_Deprovision_Response>): TransportRequestCallback;
+    deprovision (params: API.FlowFramework_Deprovision_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Deprovision_Response>): TransportRequestCallback;
+
+    provision (params: API.FlowFramework_Provision_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_Provision_Response>;
+    provision (params: API.FlowFramework_Provision_Request, callback: callbackFn<API.FlowFramework_Provision_Response>): TransportRequestCallback;
+    provision (params: API.FlowFramework_Provision_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_Provision_Response>): TransportRequestCallback;
+
+    getStatus (params: API.FlowFramework_GetStatus_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_GetStatus_Response>;
+    getStatus (params: API.FlowFramework_GetStatus_Request, callback: callbackFn<API.FlowFramework_GetStatus_Response>): TransportRequestCallback;
+    getStatus (params: API.FlowFramework_GetStatus_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_GetStatus_Response>): TransportRequestCallback;
+
+    searchState (params: API.FlowFramework_SearchState_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FlowFramework_SearchState_Response>;
+    searchState (params: API.FlowFramework_SearchState_Request, callback: callbackFn<API.FlowFramework_SearchState_Response>): TransportRequestCallback;
+    searchState (params: API.FlowFramework_SearchState_Request, options: TransportRequestOptions, callback: callbackFn<API.FlowFramework_SearchState_Response>): TransportRequestCallback;
+
+  };
+
+  indices: {
+    getAlias (params?: API.Indices_GetAlias_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetAlias_Response>;
+    getAlias (callback: callbackFn<API.Indices_GetAlias_Response>): TransportRequestCallback;
+    getAlias (params: API.Indices_GetAlias_Request, callback: callbackFn<API.Indices_GetAlias_Response>): TransportRequestCallback;
+    getAlias (params: API.Indices_GetAlias_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetAlias_Response>): TransportRequestCallback;
+
+    putAlias (params?: API.Indices_PutAlias_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_PutAlias_Response>;
+    putAlias (callback: callbackFn<API.Indices_PutAlias_Response>): TransportRequestCallback;
+    putAlias (params: API.Indices_PutAlias_Request, callback: callbackFn<API.Indices_PutAlias_Response>): TransportRequestCallback;
+    putAlias (params: API.Indices_PutAlias_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_PutAlias_Response>): TransportRequestCallback;
+
+    existsAlias (params: API.Indices_ExistsAlias_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ExistsAlias_Response>;
+    existsAlias (params: API.Indices_ExistsAlias_Request, callback: callbackFn<API.Indices_ExistsAlias_Response>): TransportRequestCallback;
+    existsAlias (params: API.Indices_ExistsAlias_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ExistsAlias_Response>): TransportRequestCallback;
+
+    updateAliases (params: API.Indices_UpdateAliases_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_UpdateAliases_Response>;
+    updateAliases (params: API.Indices_UpdateAliases_Request, callback: callbackFn<API.Indices_UpdateAliases_Response>): TransportRequestCallback;
+    updateAliases (params: API.Indices_UpdateAliases_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_UpdateAliases_Response>): TransportRequestCallback;
+
+    analyze (params?: API.Indices_Analyze_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Analyze_Response>;
+    analyze (callback: callbackFn<API.Indices_Analyze_Response>): TransportRequestCallback;
+    analyze (params: API.Indices_Analyze_Request, callback: callbackFn<API.Indices_Analyze_Response>): TransportRequestCallback;
+    analyze (params: API.Indices_Analyze_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Analyze_Response>): TransportRequestCallback;
+
+    clearCache (params?: API.Indices_ClearCache_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ClearCache_Response>;
+    clearCache (callback: callbackFn<API.Indices_ClearCache_Response>): TransportRequestCallback;
+    clearCache (params: API.Indices_ClearCache_Request, callback: callbackFn<API.Indices_ClearCache_Response>): TransportRequestCallback;
+    clearCache (params: API.Indices_ClearCache_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ClearCache_Response>): TransportRequestCallback;
+
+    getDataStream (params?: API.Indices_GetDataStream_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetDataStream_Response>;
+    getDataStream (callback: callbackFn<API.Indices_GetDataStream_Response>): TransportRequestCallback;
+    getDataStream (params: API.Indices_GetDataStream_Request, callback: callbackFn<API.Indices_GetDataStream_Response>): TransportRequestCallback;
+    getDataStream (params: API.Indices_GetDataStream_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetDataStream_Response>): TransportRequestCallback;
+
+    dataStreamsStats (params?: API.Indices_DataStreamsStats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_DataStreamsStats_Response>;
+    dataStreamsStats (callback: callbackFn<API.Indices_DataStreamsStats_Response>): TransportRequestCallback;
+    dataStreamsStats (params: API.Indices_DataStreamsStats_Request, callback: callbackFn<API.Indices_DataStreamsStats_Response>): TransportRequestCallback;
+    dataStreamsStats (params: API.Indices_DataStreamsStats_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_DataStreamsStats_Response>): TransportRequestCallback;
+
+    deleteDataStream (params: API.Indices_DeleteDataStream_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_DeleteDataStream_Response>;
+    deleteDataStream (params: API.Indices_DeleteDataStream_Request, callback: callbackFn<API.Indices_DeleteDataStream_Response>): TransportRequestCallback;
+    deleteDataStream (params: API.Indices_DeleteDataStream_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_DeleteDataStream_Response>): TransportRequestCallback;
+
+    createDataStream (params: API.Indices_CreateDataStream_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_CreateDataStream_Response>;
+    createDataStream (params: API.Indices_CreateDataStream_Request, callback: callbackFn<API.Indices_CreateDataStream_Response>): TransportRequestCallback;
+    createDataStream (params: API.Indices_CreateDataStream_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_CreateDataStream_Response>): TransportRequestCallback;
+
+    flush (params?: API.Indices_Flush_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Flush_Response>;
+    flush (callback: callbackFn<API.Indices_Flush_Response>): TransportRequestCallback;
+    flush (params: API.Indices_Flush_Request, callback: callbackFn<API.Indices_Flush_Response>): TransportRequestCallback;
+    flush (params: API.Indices_Flush_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Flush_Response>): TransportRequestCallback;
+
+    forcemerge (params?: API.Indices_Forcemerge_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Forcemerge_Response>;
+    forcemerge (callback: callbackFn<API.Indices_Forcemerge_Response>): TransportRequestCallback;
+    forcemerge (params: API.Indices_Forcemerge_Request, callback: callbackFn<API.Indices_Forcemerge_Response>): TransportRequestCallback;
+    forcemerge (params: API.Indices_Forcemerge_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Forcemerge_Response>): TransportRequestCallback;
+
+    getIndexTemplate (params?: API.Indices_GetIndexTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetIndexTemplate_Response>;
+    getIndexTemplate (callback: callbackFn<API.Indices_GetIndexTemplate_Response>): TransportRequestCallback;
+    getIndexTemplate (params: API.Indices_GetIndexTemplate_Request, callback: callbackFn<API.Indices_GetIndexTemplate_Response>): TransportRequestCallback;
+    getIndexTemplate (params: API.Indices_GetIndexTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetIndexTemplate_Response>): TransportRequestCallback;
+
+    simulateTemplate (params?: API.Indices_SimulateTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_SimulateTemplate_Response>;
+    simulateTemplate (callback: callbackFn<API.Indices_SimulateTemplate_Response>): TransportRequestCallback;
+    simulateTemplate (params: API.Indices_SimulateTemplate_Request, callback: callbackFn<API.Indices_SimulateTemplate_Response>): TransportRequestCallback;
+    simulateTemplate (params: API.Indices_SimulateTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_SimulateTemplate_Response>): TransportRequestCallback;
+
+    simulateIndexTemplate (params: API.Indices_SimulateIndexTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_SimulateIndexTemplate_Response>;
+    simulateIndexTemplate (params: API.Indices_SimulateIndexTemplate_Request, callback: callbackFn<API.Indices_SimulateIndexTemplate_Response>): TransportRequestCallback;
+    simulateIndexTemplate (params: API.Indices_SimulateIndexTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_SimulateIndexTemplate_Response>): TransportRequestCallback;
+
+    deleteIndexTemplate (params: API.Indices_DeleteIndexTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_DeleteIndexTemplate_Response>;
+    deleteIndexTemplate (params: API.Indices_DeleteIndexTemplate_Request, callback: callbackFn<API.Indices_DeleteIndexTemplate_Response>): TransportRequestCallback;
+    deleteIndexTemplate (params: API.Indices_DeleteIndexTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_DeleteIndexTemplate_Response>): TransportRequestCallback;
+
+    existsIndexTemplate (params: API.Indices_ExistsIndexTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ExistsIndexTemplate_Response>;
+    existsIndexTemplate (params: API.Indices_ExistsIndexTemplate_Request, callback: callbackFn<API.Indices_ExistsIndexTemplate_Response>): TransportRequestCallback;
+    existsIndexTemplate (params: API.Indices_ExistsIndexTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ExistsIndexTemplate_Response>): TransportRequestCallback;
+
+    putIndexTemplate (params: API.Indices_PutIndexTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_PutIndexTemplate_Response>;
+    putIndexTemplate (params: API.Indices_PutIndexTemplate_Request, callback: callbackFn<API.Indices_PutIndexTemplate_Response>): TransportRequestCallback;
+    putIndexTemplate (params: API.Indices_PutIndexTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_PutIndexTemplate_Response>): TransportRequestCallback;
+
+    getMapping (params?: API.Indices_GetMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetMapping_Response>;
+    getMapping (callback: callbackFn<API.Indices_GetMapping_Response>): TransportRequestCallback;
+    getMapping (params: API.Indices_GetMapping_Request, callback: callbackFn<API.Indices_GetMapping_Response>): TransportRequestCallback;
+    getMapping (params: API.Indices_GetMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetMapping_Response>): TransportRequestCallback;
+
+    getFieldMapping (params: API.Indices_GetFieldMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetFieldMapping_Response>;
+    getFieldMapping (params: API.Indices_GetFieldMapping_Request, callback: callbackFn<API.Indices_GetFieldMapping_Response>): TransportRequestCallback;
+    getFieldMapping (params: API.Indices_GetFieldMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetFieldMapping_Response>): TransportRequestCallback;
+
+    recovery (params?: API.Indices_Recovery_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Recovery_Response>;
+    recovery (callback: callbackFn<API.Indices_Recovery_Response>): TransportRequestCallback;
+    recovery (params: API.Indices_Recovery_Request, callback: callbackFn<API.Indices_Recovery_Response>): TransportRequestCallback;
+    recovery (params: API.Indices_Recovery_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Recovery_Response>): TransportRequestCallback;
+
+    refresh (params?: API.Indices_Refresh_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Refresh_Response>;
+    refresh (callback: callbackFn<API.Indices_Refresh_Response>): TransportRequestCallback;
+    refresh (params: API.Indices_Refresh_Request, callback: callbackFn<API.Indices_Refresh_Response>): TransportRequestCallback;
+    refresh (params: API.Indices_Refresh_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Refresh_Response>): TransportRequestCallback;
+
+    resolveIndex (params: API.Indices_ResolveIndex_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ResolveIndex_Response>;
+    resolveIndex (params: API.Indices_ResolveIndex_Request, callback: callbackFn<API.Indices_ResolveIndex_Response>): TransportRequestCallback;
+    resolveIndex (params: API.Indices_ResolveIndex_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ResolveIndex_Response>): TransportRequestCallback;
+
+    segments (params?: API.Indices_Segments_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Segments_Response>;
+    segments (callback: callbackFn<API.Indices_Segments_Response>): TransportRequestCallback;
+    segments (params: API.Indices_Segments_Request, callback: callbackFn<API.Indices_Segments_Response>): TransportRequestCallback;
+    segments (params: API.Indices_Segments_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Segments_Response>): TransportRequestCallback;
+
+    getSettings (params?: API.Indices_GetSettings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetSettings_Response>;
+    getSettings (callback: callbackFn<API.Indices_GetSettings_Response>): TransportRequestCallback;
+    getSettings (params: API.Indices_GetSettings_Request, callback: callbackFn<API.Indices_GetSettings_Response>): TransportRequestCallback;
+    getSettings (params: API.Indices_GetSettings_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetSettings_Response>): TransportRequestCallback;
+
+    putSettings (params: API.Indices_PutSettings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_PutSettings_Response>;
+    putSettings (params: API.Indices_PutSettings_Request, callback: callbackFn<API.Indices_PutSettings_Response>): TransportRequestCallback;
+    putSettings (params: API.Indices_PutSettings_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_PutSettings_Response>): TransportRequestCallback;
+
+    shardStores (params?: API.Indices_ShardStores_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ShardStores_Response>;
+    shardStores (callback: callbackFn<API.Indices_ShardStores_Response>): TransportRequestCallback;
+    shardStores (params: API.Indices_ShardStores_Request, callback: callbackFn<API.Indices_ShardStores_Response>): TransportRequestCallback;
+    shardStores (params: API.Indices_ShardStores_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ShardStores_Response>): TransportRequestCallback;
+
+    stats (params?: API.Indices_Stats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Stats_Response>;
+    stats (callback: callbackFn<API.Indices_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Indices_Stats_Request, callback: callbackFn<API.Indices_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Indices_Stats_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Stats_Response>): TransportRequestCallback;
+
+    getTemplate (params?: API.Indices_GetTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetTemplate_Response>;
+    getTemplate (callback: callbackFn<API.Indices_GetTemplate_Response>): TransportRequestCallback;
+    getTemplate (params: API.Indices_GetTemplate_Request, callback: callbackFn<API.Indices_GetTemplate_Response>): TransportRequestCallback;
+    getTemplate (params: API.Indices_GetTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetTemplate_Response>): TransportRequestCallback;
+
+    deleteTemplate (params: API.Indices_DeleteTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_DeleteTemplate_Response>;
+    deleteTemplate (params: API.Indices_DeleteTemplate_Request, callback: callbackFn<API.Indices_DeleteTemplate_Response>): TransportRequestCallback;
+    deleteTemplate (params: API.Indices_DeleteTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_DeleteTemplate_Response>): TransportRequestCallback;
+
+    existsTemplate (params: API.Indices_ExistsTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ExistsTemplate_Response>;
+    existsTemplate (params: API.Indices_ExistsTemplate_Request, callback: callbackFn<API.Indices_ExistsTemplate_Response>): TransportRequestCallback;
+    existsTemplate (params: API.Indices_ExistsTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ExistsTemplate_Response>): TransportRequestCallback;
+
+    putTemplate (params: API.Indices_PutTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_PutTemplate_Response>;
+    putTemplate (params: API.Indices_PutTemplate_Request, callback: callbackFn<API.Indices_PutTemplate_Response>): TransportRequestCallback;
+    putTemplate (params: API.Indices_PutTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_PutTemplate_Response>): TransportRequestCallback;
+
+    getUpgrade (params?: API.Indices_GetUpgrade_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_GetUpgrade_Response>;
+    getUpgrade (callback: callbackFn<API.Indices_GetUpgrade_Response>): TransportRequestCallback;
+    getUpgrade (params: API.Indices_GetUpgrade_Request, callback: callbackFn<API.Indices_GetUpgrade_Response>): TransportRequestCallback;
+    getUpgrade (params: API.Indices_GetUpgrade_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_GetUpgrade_Response>): TransportRequestCallback;
+
+    upgrade (params?: API.Indices_Upgrade_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Upgrade_Response>;
+    upgrade (callback: callbackFn<API.Indices_Upgrade_Response>): TransportRequestCallback;
+    upgrade (params: API.Indices_Upgrade_Request, callback: callbackFn<API.Indices_Upgrade_Response>): TransportRequestCallback;
+    upgrade (params: API.Indices_Upgrade_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Upgrade_Response>): TransportRequestCallback;
+
+    validateQuery (params?: API.Indices_ValidateQuery_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_ValidateQuery_Response>;
+    validateQuery (callback: callbackFn<API.Indices_ValidateQuery_Response>): TransportRequestCallback;
+    validateQuery (params: API.Indices_ValidateQuery_Request, callback: callbackFn<API.Indices_ValidateQuery_Response>): TransportRequestCallback;
+    validateQuery (params: API.Indices_ValidateQuery_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_ValidateQuery_Response>): TransportRequestCallback;
+
+    rollover (params: API.Indices_Rollover_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Rollover_Response>;
+    rollover (params: API.Indices_Rollover_Request, callback: callbackFn<API.Indices_Rollover_Response>): TransportRequestCallback;
+    rollover (params: API.Indices_Rollover_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Rollover_Response>): TransportRequestCallback;
+
+    delete (params: API.Indices_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Delete_Response>;
+    delete (params: API.Indices_Delete_Request, callback: callbackFn<API.Indices_Delete_Response>): TransportRequestCallback;
+    delete (params: API.Indices_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Delete_Response>): TransportRequestCallback;
+
+    get (params: API.Indices_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Get_Response>;
+    get (params: API.Indices_Get_Request, callback: callbackFn<API.Indices_Get_Response>): TransportRequestCallback;
+    get (params: API.Indices_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Get_Response>): TransportRequestCallback;
+
+    exists (params: API.Indices_Exists_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Exists_Response>;
+    exists (params: API.Indices_Exists_Request, callback: callbackFn<API.Indices_Exists_Response>): TransportRequestCallback;
+    exists (params: API.Indices_Exists_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Exists_Response>): TransportRequestCallback;
+
+    create (params: API.Indices_Create_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Create_Response>;
+    create (params: API.Indices_Create_Request, callback: callbackFn<API.Indices_Create_Response>): TransportRequestCallback;
+    create (params: API.Indices_Create_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Create_Response>): TransportRequestCallback;
+
+    deleteAlias (params: API.Indices_DeleteAlias_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_DeleteAlias_Response>;
+    deleteAlias (params: API.Indices_DeleteAlias_Request, callback: callbackFn<API.Indices_DeleteAlias_Response>): TransportRequestCallback;
+    deleteAlias (params: API.Indices_DeleteAlias_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_DeleteAlias_Response>): TransportRequestCallback;
+
+    addBlock (params: API.Indices_AddBlock_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_AddBlock_Response>;
+    addBlock (params: API.Indices_AddBlock_Request, callback: callbackFn<API.Indices_AddBlock_Response>): TransportRequestCallback;
+    addBlock (params: API.Indices_AddBlock_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_AddBlock_Response>): TransportRequestCallback;
+
+    clone (params: API.Indices_Clone_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Clone_Response>;
+    clone (params: API.Indices_Clone_Request, callback: callbackFn<API.Indices_Clone_Response>): TransportRequestCallback;
+    clone (params: API.Indices_Clone_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Clone_Response>): TransportRequestCallback;
+
+    close (params: API.Indices_Close_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Close_Response>;
+    close (params: API.Indices_Close_Request, callback: callbackFn<API.Indices_Close_Response>): TransportRequestCallback;
+    close (params: API.Indices_Close_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Close_Response>): TransportRequestCallback;
+
+    putMapping (params: API.Indices_PutMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_PutMapping_Response>;
+    putMapping (params: API.Indices_PutMapping_Request, callback: callbackFn<API.Indices_PutMapping_Response>): TransportRequestCallback;
+    putMapping (params: API.Indices_PutMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_PutMapping_Response>): TransportRequestCallback;
+
+    open (params: API.Indices_Open_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Open_Response>;
+    open (params: API.Indices_Open_Request, callback: callbackFn<API.Indices_Open_Response>): TransportRequestCallback;
+    open (params: API.Indices_Open_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Open_Response>): TransportRequestCallback;
+
+    shrink (params: API.Indices_Shrink_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Shrink_Response>;
+    shrink (params: API.Indices_Shrink_Request, callback: callbackFn<API.Indices_Shrink_Response>): TransportRequestCallback;
+    shrink (params: API.Indices_Shrink_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Shrink_Response>): TransportRequestCallback;
+
+    split (params: API.Indices_Split_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Indices_Split_Response>;
+    split (params: API.Indices_Split_Request, callback: callbackFn<API.Indices_Split_Response>): TransportRequestCallback;
+    split (params: API.Indices_Split_Request, options: TransportRequestOptions, callback: callbackFn<API.Indices_Split_Response>): TransportRequestCallback;
+
+  };
+
+  ingest: {
+    getPipeline (params?: API.Ingest_GetPipeline_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ingest_GetPipeline_Response>;
+    getPipeline (callback: callbackFn<API.Ingest_GetPipeline_Response>): TransportRequestCallback;
+    getPipeline (params: API.Ingest_GetPipeline_Request, callback: callbackFn<API.Ingest_GetPipeline_Response>): TransportRequestCallback;
+    getPipeline (params: API.Ingest_GetPipeline_Request, options: TransportRequestOptions, callback: callbackFn<API.Ingest_GetPipeline_Response>): TransportRequestCallback;
+
+    simulate (params: API.Ingest_Simulate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ingest_Simulate_Response>;
+    simulate (params: API.Ingest_Simulate_Request, callback: callbackFn<API.Ingest_Simulate_Response>): TransportRequestCallback;
+    simulate (params: API.Ingest_Simulate_Request, options: TransportRequestOptions, callback: callbackFn<API.Ingest_Simulate_Response>): TransportRequestCallback;
+
+    deletePipeline (params: API.Ingest_DeletePipeline_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ingest_DeletePipeline_Response>;
+    deletePipeline (params: API.Ingest_DeletePipeline_Request, callback: callbackFn<API.Ingest_DeletePipeline_Response>): TransportRequestCallback;
+    deletePipeline (params: API.Ingest_DeletePipeline_Request, options: TransportRequestOptions, callback: callbackFn<API.Ingest_DeletePipeline_Response>): TransportRequestCallback;
+
+    putPipeline (params: API.Ingest_PutPipeline_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ingest_PutPipeline_Response>;
+    putPipeline (params: API.Ingest_PutPipeline_Request, callback: callbackFn<API.Ingest_PutPipeline_Response>): TransportRequestCallback;
+    putPipeline (params: API.Ingest_PutPipeline_Request, options: TransportRequestOptions, callback: callbackFn<API.Ingest_PutPipeline_Response>): TransportRequestCallback;
+
+    processorGrok (params?: API.Ingest_ProcessorGrok_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ingest_ProcessorGrok_Response>;
+    processorGrok (callback: callbackFn<API.Ingest_ProcessorGrok_Response>): TransportRequestCallback;
+    processorGrok (params: API.Ingest_ProcessorGrok_Request, callback: callbackFn<API.Ingest_ProcessorGrok_Response>): TransportRequestCallback;
+    processorGrok (params: API.Ingest_ProcessorGrok_Request, options: TransportRequestOptions, callback: callbackFn<API.Ingest_ProcessorGrok_Response>): TransportRequestCallback;
+
+  };
+
+  ism: {
+    addPolicy (params?: API.Ism_AddPolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_AddPolicy_Response>;
+    addPolicy (callback: callbackFn<API.Ism_AddPolicy_Response>): TransportRequestCallback;
+    addPolicy (params: API.Ism_AddPolicy_Request, callback: callbackFn<API.Ism_AddPolicy_Response>): TransportRequestCallback;
+    addPolicy (params: API.Ism_AddPolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_AddPolicy_Response>): TransportRequestCallback;
+
+    changePolicy (params?: API.Ism_ChangePolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_ChangePolicy_Response>;
+    changePolicy (callback: callbackFn<API.Ism_ChangePolicy_Response>): TransportRequestCallback;
+    changePolicy (params: API.Ism_ChangePolicy_Request, callback: callbackFn<API.Ism_ChangePolicy_Response>): TransportRequestCallback;
+    changePolicy (params: API.Ism_ChangePolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_ChangePolicy_Response>): TransportRequestCallback;
+
+    explainPolicy (params?: API.Ism_ExplainPolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_ExplainPolicy_Response>;
+    explainPolicy (callback: callbackFn<API.Ism_ExplainPolicy_Response>): TransportRequestCallback;
+    explainPolicy (params: API.Ism_ExplainPolicy_Request, callback: callbackFn<API.Ism_ExplainPolicy_Response>): TransportRequestCallback;
+    explainPolicy (params: API.Ism_ExplainPolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_ExplainPolicy_Response>): TransportRequestCallback;
+
+    getPolicies (params?: API.Ism_GetPolicies_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_GetPolicies_Response>;
+    getPolicies (callback: callbackFn<API.Ism_GetPolicies_Response>): TransportRequestCallback;
+    getPolicies (params: API.Ism_GetPolicies_Request, callback: callbackFn<API.Ism_GetPolicies_Response>): TransportRequestCallback;
+    getPolicies (params: API.Ism_GetPolicies_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_GetPolicies_Response>): TransportRequestCallback;
+
+    putPolicies (params: API.Ism_PutPolicies_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_PutPolicies_Response>;
+    putPolicies (params: API.Ism_PutPolicies_Request, callback: callbackFn<API.Ism_PutPolicies_Response>): TransportRequestCallback;
+    putPolicies (params: API.Ism_PutPolicies_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_PutPolicies_Response>): TransportRequestCallback;
+
+    deletePolicy (params: API.Ism_DeletePolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_DeletePolicy_Response>;
+    deletePolicy (params: API.Ism_DeletePolicy_Request, callback: callbackFn<API.Ism_DeletePolicy_Response>): TransportRequestCallback;
+    deletePolicy (params: API.Ism_DeletePolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_DeletePolicy_Response>): TransportRequestCallback;
+
+    getPolicy (params: API.Ism_GetPolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_GetPolicy_Response>;
+    getPolicy (params: API.Ism_GetPolicy_Request, callback: callbackFn<API.Ism_GetPolicy_Response>): TransportRequestCallback;
+    getPolicy (params: API.Ism_GetPolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_GetPolicy_Response>): TransportRequestCallback;
+
+    existsPolicy (params: API.Ism_ExistsPolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_ExistsPolicy_Response>;
+    existsPolicy (params: API.Ism_ExistsPolicy_Request, callback: callbackFn<API.Ism_ExistsPolicy_Response>): TransportRequestCallback;
+    existsPolicy (params: API.Ism_ExistsPolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_ExistsPolicy_Response>): TransportRequestCallback;
+
+    putPolicy (params: API.Ism_PutPolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_PutPolicy_Response>;
+    putPolicy (params: API.Ism_PutPolicy_Request, callback: callbackFn<API.Ism_PutPolicy_Response>): TransportRequestCallback;
+    putPolicy (params: API.Ism_PutPolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_PutPolicy_Response>): TransportRequestCallback;
+
+    removePolicy (params?: API.Ism_RemovePolicy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_RemovePolicy_Response>;
+    removePolicy (callback: callbackFn<API.Ism_RemovePolicy_Response>): TransportRequestCallback;
+    removePolicy (params: API.Ism_RemovePolicy_Request, callback: callbackFn<API.Ism_RemovePolicy_Response>): TransportRequestCallback;
+    removePolicy (params: API.Ism_RemovePolicy_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_RemovePolicy_Response>): TransportRequestCallback;
+
+    retryIndex (params?: API.Ism_RetryIndex_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_RetryIndex_Response>;
+    retryIndex (callback: callbackFn<API.Ism_RetryIndex_Response>): TransportRequestCallback;
+    retryIndex (params: API.Ism_RetryIndex_Request, callback: callbackFn<API.Ism_RetryIndex_Response>): TransportRequestCallback;
+    retryIndex (params: API.Ism_RetryIndex_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_RetryIndex_Response>): TransportRequestCallback;
+
+    refreshSearchAnalyzers (params: API.Ism_RefreshSearchAnalyzers_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ism_RefreshSearchAnalyzers_Response>;
+    refreshSearchAnalyzers (params: API.Ism_RefreshSearchAnalyzers_Request, callback: callbackFn<API.Ism_RefreshSearchAnalyzers_Response>): TransportRequestCallback;
+    refreshSearchAnalyzers (params: API.Ism_RefreshSearchAnalyzers_Request, options: TransportRequestOptions, callback: callbackFn<API.Ism_RefreshSearchAnalyzers_Response>): TransportRequestCallback;
+
+  };
+
+  knn: {
+    stats (params?: API.Knn_Stats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Knn_Stats_Response>;
+    stats (callback: callbackFn<API.Knn_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Knn_Stats_Request, callback: callbackFn<API.Knn_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Knn_Stats_Request, options: TransportRequestOptions, callback: callbackFn<API.Knn_Stats_Response>): TransportRequestCallback;
+
+    searchModels (params?: API.Knn_SearchModels_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Knn_SearchModels_Response>;
+    searchModels (callback: callbackFn<API.Knn_SearchModels_Response>): TransportRequestCallback;
+    searchModels (params: API.Knn_SearchModels_Request, callback: callbackFn<API.Knn_SearchModels_Response>): TransportRequestCallback;
+    searchModels (params: API.Knn_SearchModels_Request, options: TransportRequestOptions, callback: callbackFn<API.Knn_SearchModels_Response>): TransportRequestCallback;
+
+    trainModel (params: API.Knn_TrainModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Knn_TrainModel_Response>;
+    trainModel (params: API.Knn_TrainModel_Request, callback: callbackFn<API.Knn_TrainModel_Response>): TransportRequestCallback;
+    trainModel (params: API.Knn_TrainModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Knn_TrainModel_Response>): TransportRequestCallback;
+
+    deleteModel (params: API.Knn_DeleteModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Knn_DeleteModel_Response>;
+    deleteModel (params: API.Knn_DeleteModel_Request, callback: callbackFn<API.Knn_DeleteModel_Response>): TransportRequestCallback;
+    deleteModel (params: API.Knn_DeleteModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Knn_DeleteModel_Response>): TransportRequestCallback;
+
+    getModel (params: API.Knn_GetModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Knn_GetModel_Response>;
+    getModel (params: API.Knn_GetModel_Request, callback: callbackFn<API.Knn_GetModel_Response>): TransportRequestCallback;
+    getModel (params: API.Knn_GetModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Knn_GetModel_Response>): TransportRequestCallback;
+
+    warmup (params: API.Knn_Warmup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Knn_Warmup_Response>;
+    warmup (params: API.Knn_Warmup_Request, callback: callbackFn<API.Knn_Warmup_Response>): TransportRequestCallback;
+    warmup (params: API.Knn_Warmup_Request, options: TransportRequestOptions, callback: callbackFn<API.Knn_Warmup_Response>): TransportRequestCallback;
+
+  };
+
+  ml: {
+    registerAgents (params?: API.Ml_RegisterAgents_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_RegisterAgents_Response>;
+    registerAgents (callback: callbackFn<API.Ml_RegisterAgents_Response>): TransportRequestCallback;
+    registerAgents (params: API.Ml_RegisterAgents_Request, callback: callbackFn<API.Ml_RegisterAgents_Response>): TransportRequestCallback;
+    registerAgents (params: API.Ml_RegisterAgents_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_RegisterAgents_Response>): TransportRequestCallback;
+
+    deleteAgent (params: API.Ml_DeleteAgent_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_DeleteAgent_Response>;
+    deleteAgent (params: API.Ml_DeleteAgent_Request, callback: callbackFn<API.Ml_DeleteAgent_Response>): TransportRequestCallback;
+    deleteAgent (params: API.Ml_DeleteAgent_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_DeleteAgent_Response>): TransportRequestCallback;
+
+    createConnector (params?: API.Ml_CreateConnector_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_CreateConnector_Response>;
+    createConnector (callback: callbackFn<API.Ml_CreateConnector_Response>): TransportRequestCallback;
+    createConnector (params: API.Ml_CreateConnector_Request, callback: callbackFn<API.Ml_CreateConnector_Response>): TransportRequestCallback;
+    createConnector (params: API.Ml_CreateConnector_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_CreateConnector_Response>): TransportRequestCallback;
+
+    deleteConnector (params: API.Ml_DeleteConnector_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_DeleteConnector_Response>;
+    deleteConnector (params: API.Ml_DeleteConnector_Request, callback: callbackFn<API.Ml_DeleteConnector_Response>): TransportRequestCallback;
+    deleteConnector (params: API.Ml_DeleteConnector_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_DeleteConnector_Response>): TransportRequestCallback;
+
+    registerModelGroup (params?: API.Ml_RegisterModelGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_RegisterModelGroup_Response>;
+    registerModelGroup (callback: callbackFn<API.Ml_RegisterModelGroup_Response>): TransportRequestCallback;
+    registerModelGroup (params: API.Ml_RegisterModelGroup_Request, callback: callbackFn<API.Ml_RegisterModelGroup_Response>): TransportRequestCallback;
+    registerModelGroup (params: API.Ml_RegisterModelGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_RegisterModelGroup_Response>): TransportRequestCallback;
+
+    deleteModelGroup (params: API.Ml_DeleteModelGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_DeleteModelGroup_Response>;
+    deleteModelGroup (params: API.Ml_DeleteModelGroup_Request, callback: callbackFn<API.Ml_DeleteModelGroup_Response>): TransportRequestCallback;
+    deleteModelGroup (params: API.Ml_DeleteModelGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_DeleteModelGroup_Response>): TransportRequestCallback;
+
+    getModelGroup (params: API.Ml_GetModelGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_GetModelGroup_Response>;
+    getModelGroup (params: API.Ml_GetModelGroup_Request, callback: callbackFn<API.Ml_GetModelGroup_Response>): TransportRequestCallback;
+    getModelGroup (params: API.Ml_GetModelGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_GetModelGroup_Response>): TransportRequestCallback;
+
+    registerModel (params?: API.Ml_RegisterModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_RegisterModel_Response>;
+    registerModel (callback: callbackFn<API.Ml_RegisterModel_Response>): TransportRequestCallback;
+    registerModel (params: API.Ml_RegisterModel_Request, callback: callbackFn<API.Ml_RegisterModel_Response>): TransportRequestCallback;
+    registerModel (params: API.Ml_RegisterModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_RegisterModel_Response>): TransportRequestCallback;
+
+    searchModels (params?: API.Ml_SearchModels_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_SearchModels_Response>;
+    searchModels (callback: callbackFn<API.Ml_SearchModels_Response>): TransportRequestCallback;
+    searchModels (params: API.Ml_SearchModels_Request, callback: callbackFn<API.Ml_SearchModels_Response>): TransportRequestCallback;
+    searchModels (params: API.Ml_SearchModels_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_SearchModels_Response>): TransportRequestCallback;
+
+    deleteModel (params: API.Ml_DeleteModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_DeleteModel_Response>;
+    deleteModel (params: API.Ml_DeleteModel_Request, callback: callbackFn<API.Ml_DeleteModel_Response>): TransportRequestCallback;
+    deleteModel (params: API.Ml_DeleteModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_DeleteModel_Response>): TransportRequestCallback;
+
+    deployModel (params: API.Ml_DeployModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_DeployModel_Response>;
+    deployModel (params: API.Ml_DeployModel_Request, callback: callbackFn<API.Ml_DeployModel_Response>): TransportRequestCallback;
+    deployModel (params: API.Ml_DeployModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_DeployModel_Response>): TransportRequestCallback;
+
+    undeployModel (params: API.Ml_UndeployModel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_UndeployModel_Response>;
+    undeployModel (params: API.Ml_UndeployModel_Request, callback: callbackFn<API.Ml_UndeployModel_Response>): TransportRequestCallback;
+    undeployModel (params: API.Ml_UndeployModel_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_UndeployModel_Response>): TransportRequestCallback;
+
+    deleteTask (params: API.Ml_DeleteTask_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_DeleteTask_Response>;
+    deleteTask (params: API.Ml_DeleteTask_Request, callback: callbackFn<API.Ml_DeleteTask_Response>): TransportRequestCallback;
+    deleteTask (params: API.Ml_DeleteTask_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_DeleteTask_Response>): TransportRequestCallback;
+
+    getTask (params: API.Ml_GetTask_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ml_GetTask_Response>;
+    getTask (params: API.Ml_GetTask_Request, callback: callbackFn<API.Ml_GetTask_Response>): TransportRequestCallback;
+    getTask (params: API.Ml_GetTask_Request, options: TransportRequestOptions, callback: callbackFn<API.Ml_GetTask_Response>): TransportRequestCallback;
+
+  };
+
+  nodes: {
+    info (params?: API.Nodes_Info_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Nodes_Info_Response>;
+    info (callback: callbackFn<API.Nodes_Info_Response>): TransportRequestCallback;
+    info (params: API.Nodes_Info_Request, callback: callbackFn<API.Nodes_Info_Response>): TransportRequestCallback;
+    info (params: API.Nodes_Info_Request, options: TransportRequestOptions, callback: callbackFn<API.Nodes_Info_Response>): TransportRequestCallback;
+
+    hotThreads (params?: API.Nodes_HotThreads_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Nodes_HotThreads_Response>;
+    hotThreads (callback: callbackFn<API.Nodes_HotThreads_Response>): TransportRequestCallback;
+    hotThreads (params: API.Nodes_HotThreads_Request, callback: callbackFn<API.Nodes_HotThreads_Response>): TransportRequestCallback;
+    hotThreads (params: API.Nodes_HotThreads_Request, options: TransportRequestOptions, callback: callbackFn<API.Nodes_HotThreads_Response>): TransportRequestCallback;
+
+    reloadSecureSettings (params?: API.Nodes_ReloadSecureSettings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Nodes_ReloadSecureSettings_Response>;
+    reloadSecureSettings (callback: callbackFn<API.Nodes_ReloadSecureSettings_Response>): TransportRequestCallback;
+    reloadSecureSettings (params: API.Nodes_ReloadSecureSettings_Request, callback: callbackFn<API.Nodes_ReloadSecureSettings_Response>): TransportRequestCallback;
+    reloadSecureSettings (params: API.Nodes_ReloadSecureSettings_Request, options: TransportRequestOptions, callback: callbackFn<API.Nodes_ReloadSecureSettings_Response>): TransportRequestCallback;
+
+    stats (params?: API.Nodes_Stats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Nodes_Stats_Response>;
+    stats (callback: callbackFn<API.Nodes_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Nodes_Stats_Request, callback: callbackFn<API.Nodes_Stats_Response>): TransportRequestCallback;
+    stats (params: API.Nodes_Stats_Request, options: TransportRequestOptions, callback: callbackFn<API.Nodes_Stats_Response>): TransportRequestCallback;
+
+    usage (params?: API.Nodes_Usage_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Nodes_Usage_Response>;
+    usage (callback: callbackFn<API.Nodes_Usage_Response>): TransportRequestCallback;
+    usage (params: API.Nodes_Usage_Request, callback: callbackFn<API.Nodes_Usage_Response>): TransportRequestCallback;
+    usage (params: API.Nodes_Usage_Request, options: TransportRequestOptions, callback: callbackFn<API.Nodes_Usage_Response>): TransportRequestCallback;
+
+  };
+
+  notifications: {
+    listChannels (params?: API.Notifications_ListChannels_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_ListChannels_Response>;
+    listChannels (callback: callbackFn<API.Notifications_ListChannels_Response>): TransportRequestCallback;
+    listChannels (params: API.Notifications_ListChannels_Request, callback: callbackFn<API.Notifications_ListChannels_Response>): TransportRequestCallback;
+    listChannels (params: API.Notifications_ListChannels_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_ListChannels_Response>): TransportRequestCallback;
+
+    deleteConfigs (params: API.Notifications_DeleteConfigs_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_DeleteConfigs_Response>;
+    deleteConfigs (params: API.Notifications_DeleteConfigs_Request, callback: callbackFn<API.Notifications_DeleteConfigs_Response>): TransportRequestCallback;
+    deleteConfigs (params: API.Notifications_DeleteConfigs_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_DeleteConfigs_Response>): TransportRequestCallback;
+
+    getConfigs (params?: API.Notifications_GetConfigs_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_GetConfigs_Response>;
+    getConfigs (callback: callbackFn<API.Notifications_GetConfigs_Response>): TransportRequestCallback;
+    getConfigs (params: API.Notifications_GetConfigs_Request, callback: callbackFn<API.Notifications_GetConfigs_Response>): TransportRequestCallback;
+    getConfigs (params: API.Notifications_GetConfigs_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_GetConfigs_Response>): TransportRequestCallback;
+
+    createConfig (params: API.Notifications_CreateConfig_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_CreateConfig_Response>;
+    createConfig (params: API.Notifications_CreateConfig_Request, callback: callbackFn<API.Notifications_CreateConfig_Response>): TransportRequestCallback;
+    createConfig (params: API.Notifications_CreateConfig_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_CreateConfig_Response>): TransportRequestCallback;
+
+    deleteConfig (params: API.Notifications_DeleteConfig_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_DeleteConfig_Response>;
+    deleteConfig (params: API.Notifications_DeleteConfig_Request, callback: callbackFn<API.Notifications_DeleteConfig_Response>): TransportRequestCallback;
+    deleteConfig (params: API.Notifications_DeleteConfig_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_DeleteConfig_Response>): TransportRequestCallback;
+
+    getConfig (params: API.Notifications_GetConfig_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_GetConfig_Response>;
+    getConfig (params: API.Notifications_GetConfig_Request, callback: callbackFn<API.Notifications_GetConfig_Response>): TransportRequestCallback;
+    getConfig (params: API.Notifications_GetConfig_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_GetConfig_Response>): TransportRequestCallback;
+
+    updateConfig (params: API.Notifications_UpdateConfig_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_UpdateConfig_Response>;
+    updateConfig (params: API.Notifications_UpdateConfig_Request, callback: callbackFn<API.Notifications_UpdateConfig_Response>): TransportRequestCallback;
+    updateConfig (params: API.Notifications_UpdateConfig_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_UpdateConfig_Response>): TransportRequestCallback;
+
+    sendTest (params: API.Notifications_SendTest_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_SendTest_Response>;
+    sendTest (params: API.Notifications_SendTest_Request, callback: callbackFn<API.Notifications_SendTest_Response>): TransportRequestCallback;
+    sendTest (params: API.Notifications_SendTest_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_SendTest_Response>): TransportRequestCallback;
+
+    listFeatures (params?: API.Notifications_ListFeatures_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Notifications_ListFeatures_Response>;
+    listFeatures (callback: callbackFn<API.Notifications_ListFeatures_Response>): TransportRequestCallback;
+    listFeatures (params: API.Notifications_ListFeatures_Request, callback: callbackFn<API.Notifications_ListFeatures_Response>): TransportRequestCallback;
+    listFeatures (params: API.Notifications_ListFeatures_Request, options: TransportRequestOptions, callback: callbackFn<API.Notifications_ListFeatures_Response>): TransportRequestCallback;
+
+  };
+
+  observability: {
+    getLocalstats (params?: API.Observability_GetLocalstats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_GetLocalstats_Response>;
+    getLocalstats (callback: callbackFn<API.Observability_GetLocalstats_Response>): TransportRequestCallback;
+    getLocalstats (params: API.Observability_GetLocalstats_Request, callback: callbackFn<API.Observability_GetLocalstats_Response>): TransportRequestCallback;
+    getLocalstats (params: API.Observability_GetLocalstats_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_GetLocalstats_Response>): TransportRequestCallback;
+
+    deleteObjects (params?: API.Observability_DeleteObjects_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_DeleteObjects_Response>;
+    deleteObjects (callback: callbackFn<API.Observability_DeleteObjects_Response>): TransportRequestCallback;
+    deleteObjects (params: API.Observability_DeleteObjects_Request, callback: callbackFn<API.Observability_DeleteObjects_Response>): TransportRequestCallback;
+    deleteObjects (params: API.Observability_DeleteObjects_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_DeleteObjects_Response>): TransportRequestCallback;
+
+    listObjects (params?: API.Observability_ListObjects_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_ListObjects_Response>;
+    listObjects (callback: callbackFn<API.Observability_ListObjects_Response>): TransportRequestCallback;
+    listObjects (params: API.Observability_ListObjects_Request, callback: callbackFn<API.Observability_ListObjects_Response>): TransportRequestCallback;
+    listObjects (params: API.Observability_ListObjects_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_ListObjects_Response>): TransportRequestCallback;
+
+    createObject (params?: API.Observability_CreateObject_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_CreateObject_Response>;
+    createObject (callback: callbackFn<API.Observability_CreateObject_Response>): TransportRequestCallback;
+    createObject (params: API.Observability_CreateObject_Request, callback: callbackFn<API.Observability_CreateObject_Response>): TransportRequestCallback;
+    createObject (params: API.Observability_CreateObject_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_CreateObject_Response>): TransportRequestCallback;
+
+    deleteObject (params: API.Observability_DeleteObject_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_DeleteObject_Response>;
+    deleteObject (params: API.Observability_DeleteObject_Request, callback: callbackFn<API.Observability_DeleteObject_Response>): TransportRequestCallback;
+    deleteObject (params: API.Observability_DeleteObject_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_DeleteObject_Response>): TransportRequestCallback;
+
+    getObject (params: API.Observability_GetObject_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_GetObject_Response>;
+    getObject (params: API.Observability_GetObject_Request, callback: callbackFn<API.Observability_GetObject_Response>): TransportRequestCallback;
+    getObject (params: API.Observability_GetObject_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_GetObject_Response>): TransportRequestCallback;
+
+    updateObject (params: API.Observability_UpdateObject_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Observability_UpdateObject_Response>;
+    updateObject (params: API.Observability_UpdateObject_Request, callback: callbackFn<API.Observability_UpdateObject_Response>): TransportRequestCallback;
+    updateObject (params: API.Observability_UpdateObject_Request, options: TransportRequestOptions, callback: callbackFn<API.Observability_UpdateObject_Response>): TransportRequestCallback;
+
+  };
+
+  ppl: {
+    query (params: API.Ppl_Query_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ppl_Query_Response>;
+    query (params: API.Ppl_Query_Request, callback: callbackFn<API.Ppl_Query_Response>): TransportRequestCallback;
+    query (params: API.Ppl_Query_Request, options: TransportRequestOptions, callback: callbackFn<API.Ppl_Query_Response>): TransportRequestCallback;
+
+    explain (params: API.Ppl_Explain_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ppl_Explain_Response>;
+    explain (params: API.Ppl_Explain_Request, callback: callbackFn<API.Ppl_Explain_Response>): TransportRequestCallback;
+    explain (params: API.Ppl_Explain_Request, options: TransportRequestOptions, callback: callbackFn<API.Ppl_Explain_Response>): TransportRequestCallback;
+
+    getStats (params?: API.Ppl_GetStats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ppl_GetStats_Response>;
+    getStats (callback: callbackFn<API.Ppl_GetStats_Response>): TransportRequestCallback;
+    getStats (params: API.Ppl_GetStats_Request, callback: callbackFn<API.Ppl_GetStats_Response>): TransportRequestCallback;
+    getStats (params: API.Ppl_GetStats_Request, options: TransportRequestOptions, callback: callbackFn<API.Ppl_GetStats_Response>): TransportRequestCallback;
+
+    postStats (params: API.Ppl_PostStats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ppl_PostStats_Response>;
+    postStats (params: API.Ppl_PostStats_Request, callback: callbackFn<API.Ppl_PostStats_Response>): TransportRequestCallback;
+    postStats (params: API.Ppl_PostStats_Request, options: TransportRequestOptions, callback: callbackFn<API.Ppl_PostStats_Response>): TransportRequestCallback;
+
+  };
+
+  query: {
+    datasourcesList (params?: API.Query_DatasourcesList_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Query_DatasourcesList_Response>;
+    datasourcesList (callback: callbackFn<API.Query_DatasourcesList_Response>): TransportRequestCallback;
+    datasourcesList (params: API.Query_DatasourcesList_Request, callback: callbackFn<API.Query_DatasourcesList_Response>): TransportRequestCallback;
+    datasourcesList (params: API.Query_DatasourcesList_Request, options: TransportRequestOptions, callback: callbackFn<API.Query_DatasourcesList_Response>): TransportRequestCallback;
+
+    datasourcesCreate (params?: API.Query_DatasourcesCreate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Query_DatasourcesCreate_Response>;
+    datasourcesCreate (callback: callbackFn<API.Query_DatasourcesCreate_Response>): TransportRequestCallback;
+    datasourcesCreate (params: API.Query_DatasourcesCreate_Request, callback: callbackFn<API.Query_DatasourcesCreate_Response>): TransportRequestCallback;
+    datasourcesCreate (params: API.Query_DatasourcesCreate_Request, options: TransportRequestOptions, callback: callbackFn<API.Query_DatasourcesCreate_Response>): TransportRequestCallback;
+
+    datasourcesUpdate (params?: API.Query_DatasourcesUpdate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Query_DatasourcesUpdate_Response>;
+    datasourcesUpdate (callback: callbackFn<API.Query_DatasourcesUpdate_Response>): TransportRequestCallback;
+    datasourcesUpdate (params: API.Query_DatasourcesUpdate_Request, callback: callbackFn<API.Query_DatasourcesUpdate_Response>): TransportRequestCallback;
+    datasourcesUpdate (params: API.Query_DatasourcesUpdate_Request, options: TransportRequestOptions, callback: callbackFn<API.Query_DatasourcesUpdate_Response>): TransportRequestCallback;
+
+    datasourceDelete (params: API.Query_DatasourceDelete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Query_DatasourceDelete_Response>;
+    datasourceDelete (params: API.Query_DatasourceDelete_Request, callback: callbackFn<API.Query_DatasourceDelete_Response>): TransportRequestCallback;
+    datasourceDelete (params: API.Query_DatasourceDelete_Request, options: TransportRequestOptions, callback: callbackFn<API.Query_DatasourceDelete_Response>): TransportRequestCallback;
+
+    datasourceRetrieve (params: API.Query_DatasourceRetrieve_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Query_DatasourceRetrieve_Response>;
+    datasourceRetrieve (params: API.Query_DatasourceRetrieve_Request, callback: callbackFn<API.Query_DatasourceRetrieve_Response>): TransportRequestCallback;
+    datasourceRetrieve (params: API.Query_DatasourceRetrieve_Request, options: TransportRequestOptions, callback: callbackFn<API.Query_DatasourceRetrieve_Response>): TransportRequestCallback;
+
+  };
+
+  remoteStore: {
+    restore (params: API.RemoteStore_Restore_Request, options?: TransportRequestOptions): TransportRequestPromise<API.RemoteStore_Restore_Response>;
+    restore (params: API.RemoteStore_Restore_Request, callback: callbackFn<API.RemoteStore_Restore_Response>): TransportRequestCallback;
+    restore (params: API.RemoteStore_Restore_Request, options: TransportRequestOptions, callback: callbackFn<API.RemoteStore_Restore_Response>): TransportRequestCallback;
+
+  };
+
+  rollups: {
+    delete (params: API.Rollups_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Rollups_Delete_Response>;
+    delete (params: API.Rollups_Delete_Request, callback: callbackFn<API.Rollups_Delete_Response>): TransportRequestCallback;
+    delete (params: API.Rollups_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.Rollups_Delete_Response>): TransportRequestCallback;
+
+    get (params: API.Rollups_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Rollups_Get_Response>;
+    get (params: API.Rollups_Get_Request, callback: callbackFn<API.Rollups_Get_Response>): TransportRequestCallback;
+    get (params: API.Rollups_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.Rollups_Get_Response>): TransportRequestCallback;
+
+    put (params: API.Rollups_Put_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Rollups_Put_Response>;
+    put (params: API.Rollups_Put_Request, callback: callbackFn<API.Rollups_Put_Response>): TransportRequestCallback;
+    put (params: API.Rollups_Put_Request, options: TransportRequestOptions, callback: callbackFn<API.Rollups_Put_Response>): TransportRequestCallback;
+
+    explain (params: API.Rollups_Explain_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Rollups_Explain_Response>;
+    explain (params: API.Rollups_Explain_Request, callback: callbackFn<API.Rollups_Explain_Response>): TransportRequestCallback;
+    explain (params: API.Rollups_Explain_Request, options: TransportRequestOptions, callback: callbackFn<API.Rollups_Explain_Response>): TransportRequestCallback;
+
+    start (params: API.Rollups_Start_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Rollups_Start_Response>;
+    start (params: API.Rollups_Start_Request, callback: callbackFn<API.Rollups_Start_Response>): TransportRequestCallback;
+    start (params: API.Rollups_Start_Request, options: TransportRequestOptions, callback: callbackFn<API.Rollups_Start_Response>): TransportRequestCallback;
+
+    stop (params: API.Rollups_Stop_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Rollups_Stop_Response>;
+    stop (params: API.Rollups_Stop_Request, callback: callbackFn<API.Rollups_Stop_Response>): TransportRequestCallback;
+    stop (params: API.Rollups_Stop_Request, options: TransportRequestOptions, callback: callbackFn<API.Rollups_Stop_Response>): TransportRequestCallback;
+
+  };
+
+  searchPipeline: {
+    get (params?: API.SearchPipeline_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.SearchPipeline_Get_Response>;
+    get (callback: callbackFn<API.SearchPipeline_Get_Response>): TransportRequestCallback;
+    get (params: API.SearchPipeline_Get_Request, callback: callbackFn<API.SearchPipeline_Get_Response>): TransportRequestCallback;
+    get (params: API.SearchPipeline_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.SearchPipeline_Get_Response>): TransportRequestCallback;
+
+    delete (params: API.SearchPipeline_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.SearchPipeline_Delete_Response>;
+    delete (params: API.SearchPipeline_Delete_Request, callback: callbackFn<API.SearchPipeline_Delete_Response>): TransportRequestCallback;
+    delete (params: API.SearchPipeline_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.SearchPipeline_Delete_Response>): TransportRequestCallback;
+
+    put (params: API.SearchPipeline_Put_Request, options?: TransportRequestOptions): TransportRequestPromise<API.SearchPipeline_Put_Response>;
+    put (params: API.SearchPipeline_Put_Request, callback: callbackFn<API.SearchPipeline_Put_Response>): TransportRequestCallback;
+    put (params: API.SearchPipeline_Put_Request, options: TransportRequestOptions, callback: callbackFn<API.SearchPipeline_Put_Response>): TransportRequestCallback;
+
+  };
+
+  security: {
+    getSslinfo (params?: API.Security_GetSslinfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetSslinfo_Response>;
+    getSslinfo (callback: callbackFn<API.Security_GetSslinfo_Response>): TransportRequestCallback;
+    getSslinfo (params: API.Security_GetSslinfo_Request, callback: callbackFn<API.Security_GetSslinfo_Response>): TransportRequestCallback;
+    getSslinfo (params: API.Security_GetSslinfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetSslinfo_Response>): TransportRequestCallback;
+
+    configUpgradeCheck (params?: API.Security_ConfigUpgradeCheck_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_ConfigUpgradeCheck_Response>;
+    configUpgradeCheck (callback: callbackFn<API.Security_ConfigUpgradeCheck_Response>): TransportRequestCallback;
+    configUpgradeCheck (params: API.Security_ConfigUpgradeCheck_Request, callback: callbackFn<API.Security_ConfigUpgradeCheck_Response>): TransportRequestCallback;
+    configUpgradeCheck (params: API.Security_ConfigUpgradeCheck_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_ConfigUpgradeCheck_Response>): TransportRequestCallback;
+
+    configUpgradePerform (params?: API.Security_ConfigUpgradePerform_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_ConfigUpgradePerform_Response>;
+    configUpgradePerform (callback: callbackFn<API.Security_ConfigUpgradePerform_Response>): TransportRequestCallback;
+    configUpgradePerform (params: API.Security_ConfigUpgradePerform_Request, callback: callbackFn<API.Security_ConfigUpgradePerform_Response>): TransportRequestCallback;
+    configUpgradePerform (params: API.Security_ConfigUpgradePerform_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_ConfigUpgradePerform_Response>): TransportRequestCallback;
+
+    getAccountDetails (params?: API.Security_GetAccountDetails_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetAccountDetails_Response>;
+    getAccountDetails (callback: callbackFn<API.Security_GetAccountDetails_Response>): TransportRequestCallback;
+    getAccountDetails (params: API.Security_GetAccountDetails_Request, callback: callbackFn<API.Security_GetAccountDetails_Response>): TransportRequestCallback;
+    getAccountDetails (params: API.Security_GetAccountDetails_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetAccountDetails_Response>): TransportRequestCallback;
+
+    changePassword (params: API.Security_ChangePassword_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_ChangePassword_Response>;
+    changePassword (params: API.Security_ChangePassword_Request, callback: callbackFn<API.Security_ChangePassword_Response>): TransportRequestCallback;
+    changePassword (params: API.Security_ChangePassword_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_ChangePassword_Response>): TransportRequestCallback;
+
+    getActionGroups (params?: API.Security_GetActionGroups_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetActionGroups_Response>;
+    getActionGroups (callback: callbackFn<API.Security_GetActionGroups_Response>): TransportRequestCallback;
+    getActionGroups (params: API.Security_GetActionGroups_Request, callback: callbackFn<API.Security_GetActionGroups_Response>): TransportRequestCallback;
+    getActionGroups (params: API.Security_GetActionGroups_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetActionGroups_Response>): TransportRequestCallback;
+
+    patchActionGroups (params: API.Security_PatchActionGroups_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchActionGroups_Response>;
+    patchActionGroups (params: API.Security_PatchActionGroups_Request, callback: callbackFn<API.Security_PatchActionGroups_Response>): TransportRequestCallback;
+    patchActionGroups (params: API.Security_PatchActionGroups_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchActionGroups_Response>): TransportRequestCallback;
+
+    deleteActionGroup (params: API.Security_DeleteActionGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteActionGroup_Response>;
+    deleteActionGroup (params: API.Security_DeleteActionGroup_Request, callback: callbackFn<API.Security_DeleteActionGroup_Response>): TransportRequestCallback;
+    deleteActionGroup (params: API.Security_DeleteActionGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteActionGroup_Response>): TransportRequestCallback;
+
+    getActionGroup (params: API.Security_GetActionGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetActionGroup_Response>;
+    getActionGroup (params: API.Security_GetActionGroup_Request, callback: callbackFn<API.Security_GetActionGroup_Response>): TransportRequestCallback;
+    getActionGroup (params: API.Security_GetActionGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetActionGroup_Response>): TransportRequestCallback;
+
+    patchActionGroup (params: API.Security_PatchActionGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchActionGroup_Response>;
+    patchActionGroup (params: API.Security_PatchActionGroup_Request, callback: callbackFn<API.Security_PatchActionGroup_Response>): TransportRequestCallback;
+    patchActionGroup (params: API.Security_PatchActionGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchActionGroup_Response>): TransportRequestCallback;
+
+    createActionGroup (params: API.Security_CreateActionGroup_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateActionGroup_Response>;
+    createActionGroup (params: API.Security_CreateActionGroup_Request, callback: callbackFn<API.Security_CreateActionGroup_Response>): TransportRequestCallback;
+    createActionGroup (params: API.Security_CreateActionGroup_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateActionGroup_Response>): TransportRequestCallback;
+
+    getAllowlist (params?: API.Security_GetAllowlist_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetAllowlist_Response>;
+    getAllowlist (callback: callbackFn<API.Security_GetAllowlist_Response>): TransportRequestCallback;
+    getAllowlist (params: API.Security_GetAllowlist_Request, callback: callbackFn<API.Security_GetAllowlist_Response>): TransportRequestCallback;
+    getAllowlist (params: API.Security_GetAllowlist_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetAllowlist_Response>): TransportRequestCallback;
+
+    patchAllowlist (params: API.Security_PatchAllowlist_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchAllowlist_Response>;
+    patchAllowlist (params: API.Security_PatchAllowlist_Request, callback: callbackFn<API.Security_PatchAllowlist_Response>): TransportRequestCallback;
+    patchAllowlist (params: API.Security_PatchAllowlist_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchAllowlist_Response>): TransportRequestCallback;
+
+    createAllowlist (params: API.Security_CreateAllowlist_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateAllowlist_Response>;
+    createAllowlist (params: API.Security_CreateAllowlist_Request, callback: callbackFn<API.Security_CreateAllowlist_Response>): TransportRequestCallback;
+    createAllowlist (params: API.Security_CreateAllowlist_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateAllowlist_Response>): TransportRequestCallback;
+
+    getAuditConfiguration (params?: API.Security_GetAuditConfiguration_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetAuditConfiguration_Response>;
+    getAuditConfiguration (callback: callbackFn<API.Security_GetAuditConfiguration_Response>): TransportRequestCallback;
+    getAuditConfiguration (params: API.Security_GetAuditConfiguration_Request, callback: callbackFn<API.Security_GetAuditConfiguration_Response>): TransportRequestCallback;
+    getAuditConfiguration (params: API.Security_GetAuditConfiguration_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetAuditConfiguration_Response>): TransportRequestCallback;
+
+    patchAuditConfiguration (params: API.Security_PatchAuditConfiguration_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchAuditConfiguration_Response>;
+    patchAuditConfiguration (params: API.Security_PatchAuditConfiguration_Request, callback: callbackFn<API.Security_PatchAuditConfiguration_Response>): TransportRequestCallback;
+    patchAuditConfiguration (params: API.Security_PatchAuditConfiguration_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchAuditConfiguration_Response>): TransportRequestCallback;
+
+    updateAuditConfiguration (params: API.Security_UpdateAuditConfiguration_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_UpdateAuditConfiguration_Response>;
+    updateAuditConfiguration (params: API.Security_UpdateAuditConfiguration_Request, callback: callbackFn<API.Security_UpdateAuditConfiguration_Response>): TransportRequestCallback;
+    updateAuditConfiguration (params: API.Security_UpdateAuditConfiguration_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_UpdateAuditConfiguration_Response>): TransportRequestCallback;
+
+    authtoken (params?: API.Security_Authtoken_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_Authtoken_Response>;
+    authtoken (callback: callbackFn<API.Security_Authtoken_Response>): TransportRequestCallback;
+    authtoken (params: API.Security_Authtoken_Request, callback: callbackFn<API.Security_Authtoken_Response>): TransportRequestCallback;
+    authtoken (params: API.Security_Authtoken_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_Authtoken_Response>): TransportRequestCallback;
+
+    flushCache (params?: API.Security_FlushCache_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_FlushCache_Response>;
+    flushCache (callback: callbackFn<API.Security_FlushCache_Response>): TransportRequestCallback;
+    flushCache (params: API.Security_FlushCache_Request, callback: callbackFn<API.Security_FlushCache_Response>): TransportRequestCallback;
+    flushCache (params: API.Security_FlushCache_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_FlushCache_Response>): TransportRequestCallback;
+
+    getAllCertificates (params?: API.Security_GetAllCertificates_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetAllCertificates_Response>;
+    getAllCertificates (callback: callbackFn<API.Security_GetAllCertificates_Response>): TransportRequestCallback;
+    getAllCertificates (params: API.Security_GetAllCertificates_Request, callback: callbackFn<API.Security_GetAllCertificates_Response>): TransportRequestCallback;
+    getAllCertificates (params: API.Security_GetAllCertificates_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetAllCertificates_Response>): TransportRequestCallback;
+
+    getNodeCertificates (params: API.Security_GetNodeCertificates_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetNodeCertificates_Response>;
+    getNodeCertificates (params: API.Security_GetNodeCertificates_Request, callback: callbackFn<API.Security_GetNodeCertificates_Response>): TransportRequestCallback;
+    getNodeCertificates (params: API.Security_GetNodeCertificates_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetNodeCertificates_Response>): TransportRequestCallback;
+
+    generateOboToken (params: API.Security_GenerateOboToken_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GenerateOboToken_Response>;
+    generateOboToken (params: API.Security_GenerateOboToken_Request, callback: callbackFn<API.Security_GenerateOboToken_Response>): TransportRequestCallback;
+    generateOboToken (params: API.Security_GenerateOboToken_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GenerateOboToken_Response>): TransportRequestCallback;
+
+    getUsers (params?: API.Security_GetUsers_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetUsers_Response>;
+    getUsers (callback: callbackFn<API.Security_GetUsers_Response>): TransportRequestCallback;
+    getUsers (params: API.Security_GetUsers_Request, callback: callbackFn<API.Security_GetUsers_Response>): TransportRequestCallback;
+    getUsers (params: API.Security_GetUsers_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetUsers_Response>): TransportRequestCallback;
+
+    patchUsers (params: API.Security_PatchUsers_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchUsers_Response>;
+    patchUsers (params: API.Security_PatchUsers_Request, callback: callbackFn<API.Security_PatchUsers_Response>): TransportRequestCallback;
+    patchUsers (params: API.Security_PatchUsers_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchUsers_Response>): TransportRequestCallback;
+
+    deleteUser (params: API.Security_DeleteUser_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteUser_Response>;
+    deleteUser (params: API.Security_DeleteUser_Request, callback: callbackFn<API.Security_DeleteUser_Response>): TransportRequestCallback;
+    deleteUser (params: API.Security_DeleteUser_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteUser_Response>): TransportRequestCallback;
+
+    getUser (params: API.Security_GetUser_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetUser_Response>;
+    getUser (params: API.Security_GetUser_Request, callback: callbackFn<API.Security_GetUser_Response>): TransportRequestCallback;
+    getUser (params: API.Security_GetUser_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetUser_Response>): TransportRequestCallback;
+
+    patchUser (params: API.Security_PatchUser_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchUser_Response>;
+    patchUser (params: API.Security_PatchUser_Request, callback: callbackFn<API.Security_PatchUser_Response>): TransportRequestCallback;
+    patchUser (params: API.Security_PatchUser_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchUser_Response>): TransportRequestCallback;
+
+    createUser (params: API.Security_CreateUser_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateUser_Response>;
+    createUser (params: API.Security_CreateUser_Request, callback: callbackFn<API.Security_CreateUser_Response>): TransportRequestCallback;
+    createUser (params: API.Security_CreateUser_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateUser_Response>): TransportRequestCallback;
+
+    generateUserToken (params: API.Security_GenerateUserToken_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GenerateUserToken_Response>;
+    generateUserToken (params: API.Security_GenerateUserToken_Request, callback: callbackFn<API.Security_GenerateUserToken_Response>): TransportRequestCallback;
+    generateUserToken (params: API.Security_GenerateUserToken_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GenerateUserToken_Response>): TransportRequestCallback;
+
+    migrate (params?: API.Security_Migrate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_Migrate_Response>;
+    migrate (callback: callbackFn<API.Security_Migrate_Response>): TransportRequestCallback;
+    migrate (params: API.Security_Migrate_Request, callback: callbackFn<API.Security_Migrate_Response>): TransportRequestCallback;
+    migrate (params: API.Security_Migrate_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_Migrate_Response>): TransportRequestCallback;
+
+    getDistinguishedNames (params?: API.Security_GetDistinguishedNames_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetDistinguishedNames_Response>;
+    getDistinguishedNames (callback: callbackFn<API.Security_GetDistinguishedNames_Response>): TransportRequestCallback;
+    getDistinguishedNames (params: API.Security_GetDistinguishedNames_Request, callback: callbackFn<API.Security_GetDistinguishedNames_Response>): TransportRequestCallback;
+    getDistinguishedNames (params: API.Security_GetDistinguishedNames_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetDistinguishedNames_Response>): TransportRequestCallback;
+
+    patchDistinguishedNames (params: API.Security_PatchDistinguishedNames_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchDistinguishedNames_Response>;
+    patchDistinguishedNames (params: API.Security_PatchDistinguishedNames_Request, callback: callbackFn<API.Security_PatchDistinguishedNames_Response>): TransportRequestCallback;
+    patchDistinguishedNames (params: API.Security_PatchDistinguishedNames_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchDistinguishedNames_Response>): TransportRequestCallback;
+
+    deleteDistinguishedName (params: API.Security_DeleteDistinguishedName_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteDistinguishedName_Response>;
+    deleteDistinguishedName (params: API.Security_DeleteDistinguishedName_Request, callback: callbackFn<API.Security_DeleteDistinguishedName_Response>): TransportRequestCallback;
+    deleteDistinguishedName (params: API.Security_DeleteDistinguishedName_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteDistinguishedName_Response>): TransportRequestCallback;
+
+    getDistinguishedName (params: API.Security_GetDistinguishedName_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetDistinguishedName_Response>;
+    getDistinguishedName (params: API.Security_GetDistinguishedName_Request, callback: callbackFn<API.Security_GetDistinguishedName_Response>): TransportRequestCallback;
+    getDistinguishedName (params: API.Security_GetDistinguishedName_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetDistinguishedName_Response>): TransportRequestCallback;
+
+    patchDistinguishedName (params: API.Security_PatchDistinguishedName_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchDistinguishedName_Response>;
+    patchDistinguishedName (params: API.Security_PatchDistinguishedName_Request, callback: callbackFn<API.Security_PatchDistinguishedName_Response>): TransportRequestCallback;
+    patchDistinguishedName (params: API.Security_PatchDistinguishedName_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchDistinguishedName_Response>): TransportRequestCallback;
+
+    updateDistinguishedName (params: API.Security_UpdateDistinguishedName_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_UpdateDistinguishedName_Response>;
+    updateDistinguishedName (params: API.Security_UpdateDistinguishedName_Request, callback: callbackFn<API.Security_UpdateDistinguishedName_Response>): TransportRequestCallback;
+    updateDistinguishedName (params: API.Security_UpdateDistinguishedName_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_UpdateDistinguishedName_Response>): TransportRequestCallback;
+
+    getPermissionsInfo (params?: API.Security_GetPermissionsInfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetPermissionsInfo_Response>;
+    getPermissionsInfo (callback: callbackFn<API.Security_GetPermissionsInfo_Response>): TransportRequestCallback;
+    getPermissionsInfo (params: API.Security_GetPermissionsInfo_Request, callback: callbackFn<API.Security_GetPermissionsInfo_Response>): TransportRequestCallback;
+    getPermissionsInfo (params: API.Security_GetPermissionsInfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetPermissionsInfo_Response>): TransportRequestCallback;
+
+    getRoles (params?: API.Security_GetRoles_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetRoles_Response>;
+    getRoles (callback: callbackFn<API.Security_GetRoles_Response>): TransportRequestCallback;
+    getRoles (params: API.Security_GetRoles_Request, callback: callbackFn<API.Security_GetRoles_Response>): TransportRequestCallback;
+    getRoles (params: API.Security_GetRoles_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetRoles_Response>): TransportRequestCallback;
+
+    patchRoles (params: API.Security_PatchRoles_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchRoles_Response>;
+    patchRoles (params: API.Security_PatchRoles_Request, callback: callbackFn<API.Security_PatchRoles_Response>): TransportRequestCallback;
+    patchRoles (params: API.Security_PatchRoles_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchRoles_Response>): TransportRequestCallback;
+
+    deleteRole (params: API.Security_DeleteRole_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteRole_Response>;
+    deleteRole (params: API.Security_DeleteRole_Request, callback: callbackFn<API.Security_DeleteRole_Response>): TransportRequestCallback;
+    deleteRole (params: API.Security_DeleteRole_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteRole_Response>): TransportRequestCallback;
+
+    getRole (params: API.Security_GetRole_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetRole_Response>;
+    getRole (params: API.Security_GetRole_Request, callback: callbackFn<API.Security_GetRole_Response>): TransportRequestCallback;
+    getRole (params: API.Security_GetRole_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetRole_Response>): TransportRequestCallback;
+
+    patchRole (params: API.Security_PatchRole_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchRole_Response>;
+    patchRole (params: API.Security_PatchRole_Request, callback: callbackFn<API.Security_PatchRole_Response>): TransportRequestCallback;
+    patchRole (params: API.Security_PatchRole_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchRole_Response>): TransportRequestCallback;
+
+    createRole (params: API.Security_CreateRole_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateRole_Response>;
+    createRole (params: API.Security_CreateRole_Request, callback: callbackFn<API.Security_CreateRole_Response>): TransportRequestCallback;
+    createRole (params: API.Security_CreateRole_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateRole_Response>): TransportRequestCallback;
+
+    getRoleMappings (params?: API.Security_GetRoleMappings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetRoleMappings_Response>;
+    getRoleMappings (callback: callbackFn<API.Security_GetRoleMappings_Response>): TransportRequestCallback;
+    getRoleMappings (params: API.Security_GetRoleMappings_Request, callback: callbackFn<API.Security_GetRoleMappings_Response>): TransportRequestCallback;
+    getRoleMappings (params: API.Security_GetRoleMappings_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetRoleMappings_Response>): TransportRequestCallback;
+
+    patchRoleMappings (params: API.Security_PatchRoleMappings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchRoleMappings_Response>;
+    patchRoleMappings (params: API.Security_PatchRoleMappings_Request, callback: callbackFn<API.Security_PatchRoleMappings_Response>): TransportRequestCallback;
+    patchRoleMappings (params: API.Security_PatchRoleMappings_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchRoleMappings_Response>): TransportRequestCallback;
+
+    deleteRoleMapping (params: API.Security_DeleteRoleMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteRoleMapping_Response>;
+    deleteRoleMapping (params: API.Security_DeleteRoleMapping_Request, callback: callbackFn<API.Security_DeleteRoleMapping_Response>): TransportRequestCallback;
+    deleteRoleMapping (params: API.Security_DeleteRoleMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteRoleMapping_Response>): TransportRequestCallback;
+
+    getRoleMapping (params: API.Security_GetRoleMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetRoleMapping_Response>;
+    getRoleMapping (params: API.Security_GetRoleMapping_Request, callback: callbackFn<API.Security_GetRoleMapping_Response>): TransportRequestCallback;
+    getRoleMapping (params: API.Security_GetRoleMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetRoleMapping_Response>): TransportRequestCallback;
+
+    patchRoleMapping (params: API.Security_PatchRoleMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchRoleMapping_Response>;
+    patchRoleMapping (params: API.Security_PatchRoleMapping_Request, callback: callbackFn<API.Security_PatchRoleMapping_Response>): TransportRequestCallback;
+    patchRoleMapping (params: API.Security_PatchRoleMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchRoleMapping_Response>): TransportRequestCallback;
+
+    createRoleMapping (params: API.Security_CreateRoleMapping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateRoleMapping_Response>;
+    createRoleMapping (params: API.Security_CreateRoleMapping_Request, callback: callbackFn<API.Security_CreateRoleMapping_Response>): TransportRequestCallback;
+    createRoleMapping (params: API.Security_CreateRoleMapping_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateRoleMapping_Response>): TransportRequestCallback;
+
+    getConfiguration (params?: API.Security_GetConfiguration_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetConfiguration_Response>;
+    getConfiguration (callback: callbackFn<API.Security_GetConfiguration_Response>): TransportRequestCallback;
+    getConfiguration (params: API.Security_GetConfiguration_Request, callback: callbackFn<API.Security_GetConfiguration_Response>): TransportRequestCallback;
+    getConfiguration (params: API.Security_GetConfiguration_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetConfiguration_Response>): TransportRequestCallback;
+
+    patchConfiguration (params: API.Security_PatchConfiguration_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchConfiguration_Response>;
+    patchConfiguration (params: API.Security_PatchConfiguration_Request, callback: callbackFn<API.Security_PatchConfiguration_Response>): TransportRequestCallback;
+    patchConfiguration (params: API.Security_PatchConfiguration_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchConfiguration_Response>): TransportRequestCallback;
+
+    updateConfiguration (params: API.Security_UpdateConfiguration_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_UpdateConfiguration_Response>;
+    updateConfiguration (params: API.Security_UpdateConfiguration_Request, callback: callbackFn<API.Security_UpdateConfiguration_Response>): TransportRequestCallback;
+    updateConfiguration (params: API.Security_UpdateConfiguration_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_UpdateConfiguration_Response>): TransportRequestCallback;
+
+    getCertificates (params?: API.Security_GetCertificates_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetCertificates_Response>;
+    getCertificates (callback: callbackFn<API.Security_GetCertificates_Response>): TransportRequestCallback;
+    getCertificates (params: API.Security_GetCertificates_Request, callback: callbackFn<API.Security_GetCertificates_Response>): TransportRequestCallback;
+    getCertificates (params: API.Security_GetCertificates_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetCertificates_Response>): TransportRequestCallback;
+
+    reloadHttpCertificates (params?: API.Security_ReloadHttpCertificates_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_ReloadHttpCertificates_Response>;
+    reloadHttpCertificates (callback: callbackFn<API.Security_ReloadHttpCertificates_Response>): TransportRequestCallback;
+    reloadHttpCertificates (params: API.Security_ReloadHttpCertificates_Request, callback: callbackFn<API.Security_ReloadHttpCertificates_Response>): TransportRequestCallback;
+    reloadHttpCertificates (params: API.Security_ReloadHttpCertificates_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_ReloadHttpCertificates_Response>): TransportRequestCallback;
+
+    reloadTransportCertificates (params?: API.Security_ReloadTransportCertificates_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_ReloadTransportCertificates_Response>;
+    reloadTransportCertificates (callback: callbackFn<API.Security_ReloadTransportCertificates_Response>): TransportRequestCallback;
+    reloadTransportCertificates (params: API.Security_ReloadTransportCertificates_Request, callback: callbackFn<API.Security_ReloadTransportCertificates_Response>): TransportRequestCallback;
+    reloadTransportCertificates (params: API.Security_ReloadTransportCertificates_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_ReloadTransportCertificates_Response>): TransportRequestCallback;
+
+    getTenancyConfig (params?: API.Security_GetTenancyConfig_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetTenancyConfig_Response>;
+    getTenancyConfig (callback: callbackFn<API.Security_GetTenancyConfig_Response>): TransportRequestCallback;
+    getTenancyConfig (params: API.Security_GetTenancyConfig_Request, callback: callbackFn<API.Security_GetTenancyConfig_Response>): TransportRequestCallback;
+    getTenancyConfig (params: API.Security_GetTenancyConfig_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetTenancyConfig_Response>): TransportRequestCallback;
+
+    createUpdateTenancyConfig (params: API.Security_CreateUpdateTenancyConfig_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateUpdateTenancyConfig_Response>;
+    createUpdateTenancyConfig (params: API.Security_CreateUpdateTenancyConfig_Request, callback: callbackFn<API.Security_CreateUpdateTenancyConfig_Response>): TransportRequestCallback;
+    createUpdateTenancyConfig (params: API.Security_CreateUpdateTenancyConfig_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateUpdateTenancyConfig_Response>): TransportRequestCallback;
+
+    getTenants (params?: API.Security_GetTenants_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetTenants_Response>;
+    getTenants (callback: callbackFn<API.Security_GetTenants_Response>): TransportRequestCallback;
+    getTenants (params: API.Security_GetTenants_Request, callback: callbackFn<API.Security_GetTenants_Response>): TransportRequestCallback;
+    getTenants (params: API.Security_GetTenants_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetTenants_Response>): TransportRequestCallback;
+
+    patchTenants (params: API.Security_PatchTenants_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchTenants_Response>;
+    patchTenants (params: API.Security_PatchTenants_Request, callback: callbackFn<API.Security_PatchTenants_Response>): TransportRequestCallback;
+    patchTenants (params: API.Security_PatchTenants_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchTenants_Response>): TransportRequestCallback;
+
+    deleteTenant (params: API.Security_DeleteTenant_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteTenant_Response>;
+    deleteTenant (params: API.Security_DeleteTenant_Request, callback: callbackFn<API.Security_DeleteTenant_Response>): TransportRequestCallback;
+    deleteTenant (params: API.Security_DeleteTenant_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteTenant_Response>): TransportRequestCallback;
+
+    getTenant (params: API.Security_GetTenant_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetTenant_Response>;
+    getTenant (params: API.Security_GetTenant_Request, callback: callbackFn<API.Security_GetTenant_Response>): TransportRequestCallback;
+    getTenant (params: API.Security_GetTenant_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetTenant_Response>): TransportRequestCallback;
+
+    patchTenant (params: API.Security_PatchTenant_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PatchTenant_Response>;
+    patchTenant (params: API.Security_PatchTenant_Request, callback: callbackFn<API.Security_PatchTenant_Response>): TransportRequestCallback;
+    patchTenant (params: API.Security_PatchTenant_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PatchTenant_Response>): TransportRequestCallback;
+
+    createTenant (params: API.Security_CreateTenant_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateTenant_Response>;
+    createTenant (params: API.Security_CreateTenant_Request, callback: callbackFn<API.Security_CreateTenant_Response>): TransportRequestCallback;
+    createTenant (params: API.Security_CreateTenant_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateTenant_Response>): TransportRequestCallback;
+
+    getUsersLegacy (params?: API.Security_GetUsersLegacy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetUsersLegacy_Response>;
+    getUsersLegacy (callback: callbackFn<API.Security_GetUsersLegacy_Response>): TransportRequestCallback;
+    getUsersLegacy (params: API.Security_GetUsersLegacy_Request, callback: callbackFn<API.Security_GetUsersLegacy_Response>): TransportRequestCallback;
+    getUsersLegacy (params: API.Security_GetUsersLegacy_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetUsersLegacy_Response>): TransportRequestCallback;
+
+    deleteUserLegacy (params: API.Security_DeleteUserLegacy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_DeleteUserLegacy_Response>;
+    deleteUserLegacy (params: API.Security_DeleteUserLegacy_Request, callback: callbackFn<API.Security_DeleteUserLegacy_Response>): TransportRequestCallback;
+    deleteUserLegacy (params: API.Security_DeleteUserLegacy_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_DeleteUserLegacy_Response>): TransportRequestCallback;
+
+    getUserLegacy (params: API.Security_GetUserLegacy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetUserLegacy_Response>;
+    getUserLegacy (params: API.Security_GetUserLegacy_Request, callback: callbackFn<API.Security_GetUserLegacy_Response>): TransportRequestCallback;
+    getUserLegacy (params: API.Security_GetUserLegacy_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetUserLegacy_Response>): TransportRequestCallback;
+
+    createUserLegacy (params: API.Security_CreateUserLegacy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_CreateUserLegacy_Response>;
+    createUserLegacy (params: API.Security_CreateUserLegacy_Request, callback: callbackFn<API.Security_CreateUserLegacy_Response>): TransportRequestCallback;
+    createUserLegacy (params: API.Security_CreateUserLegacy_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_CreateUserLegacy_Response>): TransportRequestCallback;
+
+    generateUserTokenLegacy (params: API.Security_GenerateUserTokenLegacy_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GenerateUserTokenLegacy_Response>;
+    generateUserTokenLegacy (params: API.Security_GenerateUserTokenLegacy_Request, callback: callbackFn<API.Security_GenerateUserTokenLegacy_Response>): TransportRequestCallback;
+    generateUserTokenLegacy (params: API.Security_GenerateUserTokenLegacy_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GenerateUserTokenLegacy_Response>): TransportRequestCallback;
+
+    validate (params?: API.Security_Validate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_Validate_Response>;
+    validate (callback: callbackFn<API.Security_Validate_Response>): TransportRequestCallback;
+    validate (params: API.Security_Validate_Request, callback: callbackFn<API.Security_Validate_Response>): TransportRequestCallback;
+    validate (params: API.Security_Validate_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_Validate_Response>): TransportRequestCallback;
+
+    authinfo (params?: API.Security_Authinfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_Authinfo_Response>;
+    authinfo (callback: callbackFn<API.Security_Authinfo_Response>): TransportRequestCallback;
+    authinfo (params: API.Security_Authinfo_Request, callback: callbackFn<API.Security_Authinfo_Response>): TransportRequestCallback;
+    authinfo (params: API.Security_Authinfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_Authinfo_Response>): TransportRequestCallback;
+
+    getDashboardsInfo (params?: API.Security_GetDashboardsInfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_GetDashboardsInfo_Response>;
+    getDashboardsInfo (callback: callbackFn<API.Security_GetDashboardsInfo_Response>): TransportRequestCallback;
+    getDashboardsInfo (params: API.Security_GetDashboardsInfo_Request, callback: callbackFn<API.Security_GetDashboardsInfo_Response>): TransportRequestCallback;
+    getDashboardsInfo (params: API.Security_GetDashboardsInfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_GetDashboardsInfo_Response>): TransportRequestCallback;
+
+    postDashboardsInfo (params?: API.Security_PostDashboardsInfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_PostDashboardsInfo_Response>;
+    postDashboardsInfo (callback: callbackFn<API.Security_PostDashboardsInfo_Response>): TransportRequestCallback;
+    postDashboardsInfo (params: API.Security_PostDashboardsInfo_Request, callback: callbackFn<API.Security_PostDashboardsInfo_Response>): TransportRequestCallback;
+    postDashboardsInfo (params: API.Security_PostDashboardsInfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_PostDashboardsInfo_Response>): TransportRequestCallback;
+
+    health (params?: API.Security_Health_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_Health_Response>;
+    health (callback: callbackFn<API.Security_Health_Response>): TransportRequestCallback;
+    health (params: API.Security_Health_Request, callback: callbackFn<API.Security_Health_Response>): TransportRequestCallback;
+    health (params: API.Security_Health_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_Health_Response>): TransportRequestCallback;
+
+    tenantInfo (params?: API.Security_TenantInfo_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_TenantInfo_Response>;
+    tenantInfo (callback: callbackFn<API.Security_TenantInfo_Response>): TransportRequestCallback;
+    tenantInfo (params: API.Security_TenantInfo_Request, callback: callbackFn<API.Security_TenantInfo_Response>): TransportRequestCallback;
+    tenantInfo (params: API.Security_TenantInfo_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_TenantInfo_Response>): TransportRequestCallback;
+
+    whoAmI (params?: API.Security_WhoAmI_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_WhoAmI_Response>;
+    whoAmI (callback: callbackFn<API.Security_WhoAmI_Response>): TransportRequestCallback;
+    whoAmI (params: API.Security_WhoAmI_Request, callback: callbackFn<API.Security_WhoAmI_Response>): TransportRequestCallback;
+    whoAmI (params: API.Security_WhoAmI_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_WhoAmI_Response>): TransportRequestCallback;
+
+    whoAmIProtected (params?: API.Security_WhoAmIProtected_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Security_WhoAmIProtected_Response>;
+    whoAmIProtected (callback: callbackFn<API.Security_WhoAmIProtected_Response>): TransportRequestCallback;
+    whoAmIProtected (params: API.Security_WhoAmIProtected_Request, callback: callbackFn<API.Security_WhoAmIProtected_Response>): TransportRequestCallback;
+    whoAmIProtected (params: API.Security_WhoAmIProtected_Request, options: TransportRequestOptions, callback: callbackFn<API.Security_WhoAmIProtected_Response>): TransportRequestCallback;
+
+  };
+
+  snapshot: {
+    getRepository (params?: API.Snapshot_GetRepository_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_GetRepository_Response>;
+    getRepository (callback: callbackFn<API.Snapshot_GetRepository_Response>): TransportRequestCallback;
+    getRepository (params: API.Snapshot_GetRepository_Request, callback: callbackFn<API.Snapshot_GetRepository_Response>): TransportRequestCallback;
+    getRepository (params: API.Snapshot_GetRepository_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_GetRepository_Response>): TransportRequestCallback;
+
+    status (params?: API.Snapshot_Status_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_Status_Response>;
+    status (callback: callbackFn<API.Snapshot_Status_Response>): TransportRequestCallback;
+    status (params: API.Snapshot_Status_Request, callback: callbackFn<API.Snapshot_Status_Response>): TransportRequestCallback;
+    status (params: API.Snapshot_Status_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_Status_Response>): TransportRequestCallback;
+
+    deleteRepository (params: API.Snapshot_DeleteRepository_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_DeleteRepository_Response>;
+    deleteRepository (params: API.Snapshot_DeleteRepository_Request, callback: callbackFn<API.Snapshot_DeleteRepository_Response>): TransportRequestCallback;
+    deleteRepository (params: API.Snapshot_DeleteRepository_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_DeleteRepository_Response>): TransportRequestCallback;
+
+    createRepository (params: API.Snapshot_CreateRepository_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_CreateRepository_Response>;
+    createRepository (params: API.Snapshot_CreateRepository_Request, callback: callbackFn<API.Snapshot_CreateRepository_Response>): TransportRequestCallback;
+    createRepository (params: API.Snapshot_CreateRepository_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_CreateRepository_Response>): TransportRequestCallback;
+
+    cleanupRepository (params: API.Snapshot_CleanupRepository_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_CleanupRepository_Response>;
+    cleanupRepository (params: API.Snapshot_CleanupRepository_Request, callback: callbackFn<API.Snapshot_CleanupRepository_Response>): TransportRequestCallback;
+    cleanupRepository (params: API.Snapshot_CleanupRepository_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_CleanupRepository_Response>): TransportRequestCallback;
+
+    verifyRepository (params: API.Snapshot_VerifyRepository_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_VerifyRepository_Response>;
+    verifyRepository (params: API.Snapshot_VerifyRepository_Request, callback: callbackFn<API.Snapshot_VerifyRepository_Response>): TransportRequestCallback;
+    verifyRepository (params: API.Snapshot_VerifyRepository_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_VerifyRepository_Response>): TransportRequestCallback;
+
+    delete (params: API.Snapshot_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_Delete_Response>;
+    delete (params: API.Snapshot_Delete_Request, callback: callbackFn<API.Snapshot_Delete_Response>): TransportRequestCallback;
+    delete (params: API.Snapshot_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_Delete_Response>): TransportRequestCallback;
+
+    get (params: API.Snapshot_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_Get_Response>;
+    get (params: API.Snapshot_Get_Request, callback: callbackFn<API.Snapshot_Get_Response>): TransportRequestCallback;
+    get (params: API.Snapshot_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_Get_Response>): TransportRequestCallback;
+
+    create (params: API.Snapshot_Create_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_Create_Response>;
+    create (params: API.Snapshot_Create_Request, callback: callbackFn<API.Snapshot_Create_Response>): TransportRequestCallback;
+    create (params: API.Snapshot_Create_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_Create_Response>): TransportRequestCallback;
+
+    clone (params: API.Snapshot_Clone_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_Clone_Response>;
+    clone (params: API.Snapshot_Clone_Request, callback: callbackFn<API.Snapshot_Clone_Response>): TransportRequestCallback;
+    clone (params: API.Snapshot_Clone_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_Clone_Response>): TransportRequestCallback;
+
+    restore (params: API.Snapshot_Restore_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Snapshot_Restore_Response>;
+    restore (params: API.Snapshot_Restore_Request, callback: callbackFn<API.Snapshot_Restore_Response>): TransportRequestCallback;
+    restore (params: API.Snapshot_Restore_Request, options: TransportRequestOptions, callback: callbackFn<API.Snapshot_Restore_Response>): TransportRequestCallback;
+
+  };
+
+  sql: {
+    settings (params: API.Sql_Settings_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Sql_Settings_Response>;
+    settings (params: API.Sql_Settings_Request, callback: callbackFn<API.Sql_Settings_Response>): TransportRequestCallback;
+    settings (params: API.Sql_Settings_Request, options: TransportRequestOptions, callback: callbackFn<API.Sql_Settings_Response>): TransportRequestCallback;
+
+    query (params: API.Sql_Query_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Sql_Query_Response>;
+    query (params: API.Sql_Query_Request, callback: callbackFn<API.Sql_Query_Response>): TransportRequestCallback;
+    query (params: API.Sql_Query_Request, options: TransportRequestOptions, callback: callbackFn<API.Sql_Query_Response>): TransportRequestCallback;
+
+    explain (params: API.Sql_Explain_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Sql_Explain_Response>;
+    explain (params: API.Sql_Explain_Request, callback: callbackFn<API.Sql_Explain_Response>): TransportRequestCallback;
+    explain (params: API.Sql_Explain_Request, options: TransportRequestOptions, callback: callbackFn<API.Sql_Explain_Response>): TransportRequestCallback;
+
+    close (params: API.Sql_Close_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Sql_Close_Response>;
+    close (params: API.Sql_Close_Request, callback: callbackFn<API.Sql_Close_Response>): TransportRequestCallback;
+    close (params: API.Sql_Close_Request, options: TransportRequestOptions, callback: callbackFn<API.Sql_Close_Response>): TransportRequestCallback;
+
+    getStats (params?: API.Sql_GetStats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Sql_GetStats_Response>;
+    getStats (callback: callbackFn<API.Sql_GetStats_Response>): TransportRequestCallback;
+    getStats (params: API.Sql_GetStats_Request, callback: callbackFn<API.Sql_GetStats_Response>): TransportRequestCallback;
+    getStats (params: API.Sql_GetStats_Request, options: TransportRequestOptions, callback: callbackFn<API.Sql_GetStats_Response>): TransportRequestCallback;
+
+    postStats (params: API.Sql_PostStats_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Sql_PostStats_Response>;
+    postStats (params: API.Sql_PostStats_Request, callback: callbackFn<API.Sql_PostStats_Response>): TransportRequestCallback;
+    postStats (params: API.Sql_PostStats_Request, options: TransportRequestOptions, callback: callbackFn<API.Sql_PostStats_Response>): TransportRequestCallback;
+
+  };
+
+  tasks: {
+    list (params?: API.Tasks_List_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Tasks_List_Response>;
+    list (callback: callbackFn<API.Tasks_List_Response>): TransportRequestCallback;
+    list (params: API.Tasks_List_Request, callback: callbackFn<API.Tasks_List_Response>): TransportRequestCallback;
+    list (params: API.Tasks_List_Request, options: TransportRequestOptions, callback: callbackFn<API.Tasks_List_Response>): TransportRequestCallback;
+
+    cancel (params?: API.Tasks_Cancel_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Tasks_Cancel_Response>;
+    cancel (callback: callbackFn<API.Tasks_Cancel_Response>): TransportRequestCallback;
+    cancel (params: API.Tasks_Cancel_Request, callback: callbackFn<API.Tasks_Cancel_Response>): TransportRequestCallback;
+    cancel (params: API.Tasks_Cancel_Request, options: TransportRequestOptions, callback: callbackFn<API.Tasks_Cancel_Response>): TransportRequestCallback;
+
+    get (params: API.Tasks_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Tasks_Get_Response>;
+    get (params: API.Tasks_Get_Request, callback: callbackFn<API.Tasks_Get_Response>): TransportRequestCallback;
+    get (params: API.Tasks_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.Tasks_Get_Response>): TransportRequestCallback;
+
+  };
+
+  transforms: {
+    search (params?: API.Transforms_Search_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Search_Response>;
+    search (callback: callbackFn<API.Transforms_Search_Response>): TransportRequestCallback;
+    search (params: API.Transforms_Search_Request, callback: callbackFn<API.Transforms_Search_Response>): TransportRequestCallback;
+    search (params: API.Transforms_Search_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Search_Response>): TransportRequestCallback;
+
+    preview (params?: API.Transforms_Preview_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Preview_Response>;
+    preview (callback: callbackFn<API.Transforms_Preview_Response>): TransportRequestCallback;
+    preview (params: API.Transforms_Preview_Request, callback: callbackFn<API.Transforms_Preview_Response>): TransportRequestCallback;
+    preview (params: API.Transforms_Preview_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Preview_Response>): TransportRequestCallback;
+
+    delete (params: API.Transforms_Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Delete_Response>;
+    delete (params: API.Transforms_Delete_Request, callback: callbackFn<API.Transforms_Delete_Response>): TransportRequestCallback;
+    delete (params: API.Transforms_Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Delete_Response>): TransportRequestCallback;
+
+    get (params: API.Transforms_Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Get_Response>;
+    get (params: API.Transforms_Get_Request, callback: callbackFn<API.Transforms_Get_Response>): TransportRequestCallback;
+    get (params: API.Transforms_Get_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Get_Response>): TransportRequestCallback;
+
+    put (params: API.Transforms_Put_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Put_Response>;
+    put (params: API.Transforms_Put_Request, callback: callbackFn<API.Transforms_Put_Response>): TransportRequestCallback;
+    put (params: API.Transforms_Put_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Put_Response>): TransportRequestCallback;
+
+    explain (params: API.Transforms_Explain_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Explain_Response>;
+    explain (params: API.Transforms_Explain_Request, callback: callbackFn<API.Transforms_Explain_Response>): TransportRequestCallback;
+    explain (params: API.Transforms_Explain_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Explain_Response>): TransportRequestCallback;
+
+    start (params: API.Transforms_Start_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Start_Response>;
+    start (params: API.Transforms_Start_Request, callback: callbackFn<API.Transforms_Start_Response>): TransportRequestCallback;
+    start (params: API.Transforms_Start_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Start_Response>): TransportRequestCallback;
+
+    stop (params: API.Transforms_Stop_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Transforms_Stop_Response>;
+    stop (params: API.Transforms_Stop_Request, callback: callbackFn<API.Transforms_Stop_Response>): TransportRequestCallback;
+    stop (params: API.Transforms_Stop_Request, options: TransportRequestOptions, callback: callbackFn<API.Transforms_Stop_Response>): TransportRequestCallback;
+
+  };
+
+
+  http: {
+    connect (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    connect (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    connect (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    delete (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    delete (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    delete (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    get (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    get (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    get (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    head (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    head (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    head (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    options (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    options (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    options (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    patch (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    patch (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    patch (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    post (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    post (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    post (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    put (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    put (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    put (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+    trace (params: HttpRequest, options?: TransportRequestOptions): TransportRequestPromise<ApiResponse>;
+    trace (params: HttpRequest, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+    trace (params: HttpRequest, options: TransportRequestOptions, callback: callbackFn<ApiResponse>): TransportRequestCallback;
+
+  };
+
+  info (params?: API.Info_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Info_Response>;
+  info (callback: callbackFn<API.Info_Response>): TransportRequestCallback;
+  info (params: API.Info_Request, callback: callbackFn<API.Info_Response>): TransportRequestCallback;
+  info (params: API.Info_Request, options: TransportRequestOptions, callback: callbackFn<API.Info_Response>): TransportRequestCallback;
+
+  ping (params?: API.Ping_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Ping_Response>;
+  ping (callback: callbackFn<API.Ping_Response>): TransportRequestCallback;
+  ping (params: API.Ping_Request, callback: callbackFn<API.Ping_Response>): TransportRequestCallback;
+  ping (params: API.Ping_Request, options: TransportRequestOptions, callback: callbackFn<API.Ping_Response>): TransportRequestCallback;
+
+  bulk (params: API.Bulk_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Bulk_Response>;
+  bulk (params: API.Bulk_Request, callback: callbackFn<API.Bulk_Response>): TransportRequestCallback;
+  bulk (params: API.Bulk_Request, options: TransportRequestOptions, callback: callbackFn<API.Bulk_Response>): TransportRequestCallback;
+
+  count (params?: API.Count_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Count_Response>;
+  count (callback: callbackFn<API.Count_Response>): TransportRequestCallback;
+  count (params: API.Count_Request, callback: callbackFn<API.Count_Response>): TransportRequestCallback;
+  count (params: API.Count_Request, options: TransportRequestOptions, callback: callbackFn<API.Count_Response>): TransportRequestCallback;
+
+  deleteByQueryRethrottle (params: API.DeleteByQueryRethrottle_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DeleteByQueryRethrottle_Response>;
+  deleteByQueryRethrottle (params: API.DeleteByQueryRethrottle_Request, callback: callbackFn<API.DeleteByQueryRethrottle_Response>): TransportRequestCallback;
+  deleteByQueryRethrottle (params: API.DeleteByQueryRethrottle_Request, options: TransportRequestOptions, callback: callbackFn<API.DeleteByQueryRethrottle_Response>): TransportRequestCallback;
+
+  fieldCaps (params?: API.FieldCaps_Request, options?: TransportRequestOptions): TransportRequestPromise<API.FieldCaps_Response>;
+  fieldCaps (callback: callbackFn<API.FieldCaps_Response>): TransportRequestCallback;
+  fieldCaps (params: API.FieldCaps_Request, callback: callbackFn<API.FieldCaps_Response>): TransportRequestCallback;
+  fieldCaps (params: API.FieldCaps_Request, options: TransportRequestOptions, callback: callbackFn<API.FieldCaps_Response>): TransportRequestCallback;
+
+  mget (params: API.Mget_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Mget_Response>;
+  mget (params: API.Mget_Request, callback: callbackFn<API.Mget_Response>): TransportRequestCallback;
+  mget (params: API.Mget_Request, options: TransportRequestOptions, callback: callbackFn<API.Mget_Response>): TransportRequestCallback;
+
+  msearch (params: API.Msearch_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Msearch_Response>;
+  msearch (params: API.Msearch_Request, callback: callbackFn<API.Msearch_Response>): TransportRequestCallback;
+  msearch (params: API.Msearch_Request, options: TransportRequestOptions, callback: callbackFn<API.Msearch_Response>): TransportRequestCallback;
+
+  msearchTemplate (params: API.MsearchTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.MsearchTemplate_Response>;
+  msearchTemplate (params: API.MsearchTemplate_Request, callback: callbackFn<API.MsearchTemplate_Response>): TransportRequestCallback;
+  msearchTemplate (params: API.MsearchTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.MsearchTemplate_Response>): TransportRequestCallback;
+
+  mtermvectors (params?: API.Mtermvectors_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Mtermvectors_Response>;
+  mtermvectors (callback: callbackFn<API.Mtermvectors_Response>): TransportRequestCallback;
+  mtermvectors (params: API.Mtermvectors_Request, callback: callbackFn<API.Mtermvectors_Response>): TransportRequestCallback;
+  mtermvectors (params: API.Mtermvectors_Request, options: TransportRequestOptions, callback: callbackFn<API.Mtermvectors_Response>): TransportRequestCallback;
+
+  rankEval (params: API.RankEval_Request, options?: TransportRequestOptions): TransportRequestPromise<API.RankEval_Response>;
+  rankEval (params: API.RankEval_Request, callback: callbackFn<API.RankEval_Response>): TransportRequestCallback;
+  rankEval (params: API.RankEval_Request, options: TransportRequestOptions, callback: callbackFn<API.RankEval_Response>): TransportRequestCallback;
+
+  reindex (params: API.Reindex_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Reindex_Response>;
+  reindex (params: API.Reindex_Request, callback: callbackFn<API.Reindex_Response>): TransportRequestCallback;
+  reindex (params: API.Reindex_Request, options: TransportRequestOptions, callback: callbackFn<API.Reindex_Response>): TransportRequestCallback;
+
+  reindexRethrottle (params: API.ReindexRethrottle_Request, options?: TransportRequestOptions): TransportRequestPromise<API.ReindexRethrottle_Response>;
+  reindexRethrottle (params: API.ReindexRethrottle_Request, callback: callbackFn<API.ReindexRethrottle_Response>): TransportRequestCallback;
+  reindexRethrottle (params: API.ReindexRethrottle_Request, options: TransportRequestOptions, callback: callbackFn<API.ReindexRethrottle_Response>): TransportRequestCallback;
+
+  renderSearchTemplate (params?: API.RenderSearchTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.RenderSearchTemplate_Response>;
+  renderSearchTemplate (callback: callbackFn<API.RenderSearchTemplate_Response>): TransportRequestCallback;
+  renderSearchTemplate (params: API.RenderSearchTemplate_Request, callback: callbackFn<API.RenderSearchTemplate_Response>): TransportRequestCallback;
+  renderSearchTemplate (params: API.RenderSearchTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.RenderSearchTemplate_Response>): TransportRequestCallback;
+
+  getScriptContext (params?: API.GetScriptContext_Request, options?: TransportRequestOptions): TransportRequestPromise<API.GetScriptContext_Response>;
+  getScriptContext (callback: callbackFn<API.GetScriptContext_Response>): TransportRequestCallback;
+  getScriptContext (params: API.GetScriptContext_Request, callback: callbackFn<API.GetScriptContext_Response>): TransportRequestCallback;
+  getScriptContext (params: API.GetScriptContext_Request, options: TransportRequestOptions, callback: callbackFn<API.GetScriptContext_Response>): TransportRequestCallback;
+
+  getScriptLanguages (params?: API.GetScriptLanguages_Request, options?: TransportRequestOptions): TransportRequestPromise<API.GetScriptLanguages_Response>;
+  getScriptLanguages (callback: callbackFn<API.GetScriptLanguages_Response>): TransportRequestCallback;
+  getScriptLanguages (params: API.GetScriptLanguages_Request, callback: callbackFn<API.GetScriptLanguages_Response>): TransportRequestCallback;
+  getScriptLanguages (params: API.GetScriptLanguages_Request, options: TransportRequestOptions, callback: callbackFn<API.GetScriptLanguages_Response>): TransportRequestCallback;
+
+  deleteScript (params: API.DeleteScript_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DeleteScript_Response>;
+  deleteScript (params: API.DeleteScript_Request, callback: callbackFn<API.DeleteScript_Response>): TransportRequestCallback;
+  deleteScript (params: API.DeleteScript_Request, options: TransportRequestOptions, callback: callbackFn<API.DeleteScript_Response>): TransportRequestCallback;
+
+  getScript (params: API.GetScript_Request, options?: TransportRequestOptions): TransportRequestPromise<API.GetScript_Response>;
+  getScript (params: API.GetScript_Request, callback: callbackFn<API.GetScript_Response>): TransportRequestCallback;
+  getScript (params: API.GetScript_Request, options: TransportRequestOptions, callback: callbackFn<API.GetScript_Response>): TransportRequestCallback;
+
+  putScript (params: API.PutScript_Request, options?: TransportRequestOptions): TransportRequestPromise<API.PutScript_Response>;
+  putScript (params: API.PutScript_Request, callback: callbackFn<API.PutScript_Response>): TransportRequestCallback;
+  putScript (params: API.PutScript_Request, options: TransportRequestOptions, callback: callbackFn<API.PutScript_Response>): TransportRequestCallback;
+
+  scriptsPainlessExecute (params?: API.ScriptsPainlessExecute_Request, options?: TransportRequestOptions): TransportRequestPromise<API.ScriptsPainlessExecute_Response>;
+  scriptsPainlessExecute (callback: callbackFn<API.ScriptsPainlessExecute_Response>): TransportRequestCallback;
+  scriptsPainlessExecute (params: API.ScriptsPainlessExecute_Request, callback: callbackFn<API.ScriptsPainlessExecute_Response>): TransportRequestCallback;
+  scriptsPainlessExecute (params: API.ScriptsPainlessExecute_Request, options: TransportRequestOptions, callback: callbackFn<API.ScriptsPainlessExecute_Response>): TransportRequestCallback;
+
+  search (params?: API.Search_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Search_Response>;
+  search (callback: callbackFn<API.Search_Response>): TransportRequestCallback;
+  search (params: API.Search_Request, callback: callbackFn<API.Search_Response>): TransportRequestCallback;
+  search (params: API.Search_Request, options: TransportRequestOptions, callback: callbackFn<API.Search_Response>): TransportRequestCallback;
+
+  searchShards (params?: API.SearchShards_Request, options?: TransportRequestOptions): TransportRequestPromise<API.SearchShards_Response>;
+  searchShards (callback: callbackFn<API.SearchShards_Response>): TransportRequestCallback;
+  searchShards (params: API.SearchShards_Request, callback: callbackFn<API.SearchShards_Response>): TransportRequestCallback;
+  searchShards (params: API.SearchShards_Request, options: TransportRequestOptions, callback: callbackFn<API.SearchShards_Response>): TransportRequestCallback;
+
+  deletePit (params?: API.DeletePit_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DeletePit_Response>;
+  deletePit (callback: callbackFn<API.DeletePit_Response>): TransportRequestCallback;
+  deletePit (params: API.DeletePit_Request, callback: callbackFn<API.DeletePit_Response>): TransportRequestCallback;
+  deletePit (params: API.DeletePit_Request, options: TransportRequestOptions, callback: callbackFn<API.DeletePit_Response>): TransportRequestCallback;
+
+  deleteAllPits (params?: API.DeleteAllPits_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DeleteAllPits_Response>;
+  deleteAllPits (callback: callbackFn<API.DeleteAllPits_Response>): TransportRequestCallback;
+  deleteAllPits (params: API.DeleteAllPits_Request, callback: callbackFn<API.DeleteAllPits_Response>): TransportRequestCallback;
+  deleteAllPits (params: API.DeleteAllPits_Request, options: TransportRequestOptions, callback: callbackFn<API.DeleteAllPits_Response>): TransportRequestCallback;
+
+  getAllPits (params?: API.GetAllPits_Request, options?: TransportRequestOptions): TransportRequestPromise<API.GetAllPits_Response>;
+  getAllPits (callback: callbackFn<API.GetAllPits_Response>): TransportRequestCallback;
+  getAllPits (params: API.GetAllPits_Request, callback: callbackFn<API.GetAllPits_Response>): TransportRequestCallback;
+  getAllPits (params: API.GetAllPits_Request, options: TransportRequestOptions, callback: callbackFn<API.GetAllPits_Response>): TransportRequestCallback;
+
+  clearScroll (params?: API.ClearScroll_Request, options?: TransportRequestOptions): TransportRequestPromise<API.ClearScroll_Response>;
+  clearScroll (callback: callbackFn<API.ClearScroll_Response>): TransportRequestCallback;
+  clearScroll (params: API.ClearScroll_Request, callback: callbackFn<API.ClearScroll_Response>): TransportRequestCallback;
+  clearScroll (params: API.ClearScroll_Request, options: TransportRequestOptions, callback: callbackFn<API.ClearScroll_Response>): TransportRequestCallback;
+
+  scroll (params?: API.Scroll_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Scroll_Response>;
+  scroll (callback: callbackFn<API.Scroll_Response>): TransportRequestCallback;
+  scroll (params: API.Scroll_Request, callback: callbackFn<API.Scroll_Response>): TransportRequestCallback;
+  scroll (params: API.Scroll_Request, options: TransportRequestOptions, callback: callbackFn<API.Scroll_Response>): TransportRequestCallback;
+
+  searchTemplate (params: API.SearchTemplate_Request, options?: TransportRequestOptions): TransportRequestPromise<API.SearchTemplate_Response>;
+  searchTemplate (params: API.SearchTemplate_Request, callback: callbackFn<API.SearchTemplate_Response>): TransportRequestCallback;
+  searchTemplate (params: API.SearchTemplate_Request, options: TransportRequestOptions, callback: callbackFn<API.SearchTemplate_Response>): TransportRequestCallback;
+
+  updateByQueryRethrottle (params: API.UpdateByQueryRethrottle_Request, options?: TransportRequestOptions): TransportRequestPromise<API.UpdateByQueryRethrottle_Response>;
+  updateByQueryRethrottle (params: API.UpdateByQueryRethrottle_Request, callback: callbackFn<API.UpdateByQueryRethrottle_Response>): TransportRequestCallback;
+  updateByQueryRethrottle (params: API.UpdateByQueryRethrottle_Request, options: TransportRequestOptions, callback: callbackFn<API.UpdateByQueryRethrottle_Response>): TransportRequestCallback;
+
+  create (params: API.Create_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Create_Response>;
+  create (params: API.Create_Request, callback: callbackFn<API.Create_Response>): TransportRequestCallback;
+  create (params: API.Create_Request, options: TransportRequestOptions, callback: callbackFn<API.Create_Response>): TransportRequestCallback;
+
+  deleteByQuery (params: API.DeleteByQuery_Request, options?: TransportRequestOptions): TransportRequestPromise<API.DeleteByQuery_Response>;
+  deleteByQuery (params: API.DeleteByQuery_Request, callback: callbackFn<API.DeleteByQuery_Response>): TransportRequestCallback;
+  deleteByQuery (params: API.DeleteByQuery_Request, options: TransportRequestOptions, callback: callbackFn<API.DeleteByQuery_Response>): TransportRequestCallback;
+
+  index (params: API.Index_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Index_Response>;
+  index (params: API.Index_Request, callback: callbackFn<API.Index_Response>): TransportRequestCallback;
+  index (params: API.Index_Request, options: TransportRequestOptions, callback: callbackFn<API.Index_Response>): TransportRequestCallback;
+
+  delete (params: API.Delete_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Delete_Response>;
+  delete (params: API.Delete_Request, callback: callbackFn<API.Delete_Response>): TransportRequestCallback;
+  delete (params: API.Delete_Request, options: TransportRequestOptions, callback: callbackFn<API.Delete_Response>): TransportRequestCallback;
+
+  get (params: API.Get_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Get_Response>;
+  get (params: API.Get_Request, callback: callbackFn<API.Get_Response>): TransportRequestCallback;
+  get (params: API.Get_Request, options: TransportRequestOptions, callback: callbackFn<API.Get_Response>): TransportRequestCallback;
+
+  exists (params: API.Exists_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Exists_Response>;
+  exists (params: API.Exists_Request, callback: callbackFn<API.Exists_Response>): TransportRequestCallback;
+  exists (params: API.Exists_Request, options: TransportRequestOptions, callback: callbackFn<API.Exists_Response>): TransportRequestCallback;
+
+  explain (params: API.Explain_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Explain_Response>;
+  explain (params: API.Explain_Request, callback: callbackFn<API.Explain_Response>): TransportRequestCallback;
+  explain (params: API.Explain_Request, options: TransportRequestOptions, callback: callbackFn<API.Explain_Response>): TransportRequestCallback;
+
+  createPit (params: API.CreatePit_Request, options?: TransportRequestOptions): TransportRequestPromise<API.CreatePit_Response>;
+  createPit (params: API.CreatePit_Request, callback: callbackFn<API.CreatePit_Response>): TransportRequestCallback;
+  createPit (params: API.CreatePit_Request, options: TransportRequestOptions, callback: callbackFn<API.CreatePit_Response>): TransportRequestCallback;
+
+  getSource (params: API.GetSource_Request, options?: TransportRequestOptions): TransportRequestPromise<API.GetSource_Response>;
+  getSource (params: API.GetSource_Request, callback: callbackFn<API.GetSource_Response>): TransportRequestCallback;
+  getSource (params: API.GetSource_Request, options: TransportRequestOptions, callback: callbackFn<API.GetSource_Response>): TransportRequestCallback;
+
+  existsSource (params: API.ExistsSource_Request, options?: TransportRequestOptions): TransportRequestPromise<API.ExistsSource_Response>;
+  existsSource (params: API.ExistsSource_Request, callback: callbackFn<API.ExistsSource_Response>): TransportRequestCallback;
+  existsSource (params: API.ExistsSource_Request, options: TransportRequestOptions, callback: callbackFn<API.ExistsSource_Response>): TransportRequestCallback;
+
+  termvectors (params: API.Termvectors_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Termvectors_Response>;
+  termvectors (params: API.Termvectors_Request, callback: callbackFn<API.Termvectors_Response>): TransportRequestCallback;
+  termvectors (params: API.Termvectors_Request, options: TransportRequestOptions, callback: callbackFn<API.Termvectors_Response>): TransportRequestCallback;
+
+  updateByQuery (params: API.UpdateByQuery_Request, options?: TransportRequestOptions): TransportRequestPromise<API.UpdateByQuery_Response>;
+  updateByQuery (params: API.UpdateByQuery_Request, callback: callbackFn<API.UpdateByQuery_Response>): TransportRequestCallback;
+  updateByQuery (params: API.UpdateByQuery_Request, options: TransportRequestOptions, callback: callbackFn<API.UpdateByQuery_Response>): TransportRequestCallback;
+
+  update (params: API.Update_Request, options?: TransportRequestOptions): TransportRequestPromise<API.Update_Response>;
+  update (params: API.Update_Request, callback: callbackFn<API.Update_Response>): TransportRequestCallback;
+  update (params: API.Update_Request, options: TransportRequestOptions, callback: callbackFn<API.Update_Response>): TransportRequestCallback;
+
+}
\ No newline at end of file
diff --git a/api/OpenSearchApi.js b/api/OpenSearchApi.js
new file mode 100644
index 000000000..272ddbbbf
--- /dev/null
+++ b/api/OpenSearchApi.js
@@ -0,0 +1,187 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ *
+ */
+
+/*
+ * This file was generated from the OpenSearch API Spec. Do NOT edit it
+ * manually. If you want to make changes, either update the spec or
+ * modify the API generator.
+ */
+
+'use strict';
+
+const { kConfigErr } = require('./utils')
+const kApiModules = Symbol('api modules')
+
+class OpenSearchAPI {
+  constructor (opts) {
+    this[kConfigErr] = opts.ConfigurationError
+    this[kApiModules] = {
+      asynchronousSearch: new(require('./asynchronousSearch/_api'))(this),
+      cat: new(require('./cat/_api'))(this),
+      cluster: new(require('./cluster/_api'))(this),
+      danglingIndices: new(require('./danglingIndices/_api'))(this),
+      flowFramework: new(require('./flowFramework/_api'))(this),
+      http: new(require('./http/_api'))(this),
+      indices: new(require('./indices/_api'))(this),
+      ingest: new(require('./ingest/_api'))(this),
+      ism: new(require('./ism/_api'))(this),
+      knn: new(require('./knn/_api'))(this),
+      ml: new(require('./ml/_api'))(this),
+      nodes: new(require('./nodes/_api'))(this),
+      notifications: new(require('./notifications/_api'))(this),
+      observability: new(require('./observability/_api'))(this),
+      ppl: new(require('./ppl/_api'))(this),
+      query: new(require('./query/_api'))(this),
+      remoteStore: new(require('./remoteStore/_api'))(this),
+      rollups: new(require('./rollups/_api'))(this),
+      searchPipeline: new(require('./searchPipeline/_api'))(this),
+      security: new(require('./security/_api'))(this),
+      snapshot: new(require('./snapshot/_api'))(this),
+      sql: new(require('./sql/_api'))(this),
+      tasks: new(require('./tasks/_api'))(this),
+      transforms: new(require('./transforms/_api'))(this),
+    }
+
+    // Setup Root API Functions
+    /** @namespace API-Core */
+    this.bulk = require('./_core/bulk').bind(this)
+    this.clearScroll = require('./_core/clearScroll').bind(this)
+    this.count = require('./_core/count').bind(this)
+    this.create = require('./_core/create').bind(this)
+    this.createPit = require('./_core/createPit').bind(this)
+    this.delete = require('./_core/delete').bind(this)
+    this.deleteAllPits = require('./_core/deleteAllPits').bind(this)
+    this.deleteByQuery = require('./_core/deleteByQuery').bind(this)
+    this.deleteByQueryRethrottle = require('./_core/deleteByQueryRethrottle').bind(this)
+    this.deletePit = require('./_core/deletePit').bind(this)
+    this.deleteScript = require('./_core/deleteScript').bind(this)
+    this.exists = require('./_core/exists').bind(this)
+    this.existsSource = require('./_core/existsSource').bind(this)
+    this.explain = require('./_core/explain').bind(this)
+    this.fieldCaps = require('./_core/fieldCaps').bind(this)
+    this.get = require('./_core/get').bind(this)
+    this.getAllPits = require('./_core/getAllPits').bind(this)
+    this.getScript = require('./_core/getScript').bind(this)
+    this.getScriptContext = require('./_core/getScriptContext').bind(this)
+    this.getScriptLanguages = require('./_core/getScriptLanguages').bind(this)
+    this.getSource = require('./_core/getSource').bind(this)
+    this.index = require('./_core/index').bind(this)
+    this.info = require('./_core/info').bind(this)
+    this.mget = require('./_core/mget').bind(this)
+    this.msearch = require('./_core/msearch').bind(this)
+    this.msearchTemplate = require('./_core/msearchTemplate').bind(this)
+    this.mtermvectors = require('./_core/mtermvectors').bind(this)
+    this.ping = require('./_core/ping').bind(this)
+    this.putScript = require('./_core/putScript').bind(this)
+    this.rankEval = require('./_core/rankEval').bind(this)
+    this.reindex = require('./_core/reindex').bind(this)
+    this.reindexRethrottle = require('./_core/reindexRethrottle').bind(this)
+    this.renderSearchTemplate = require('./_core/renderSearchTemplate').bind(this)
+    this.scriptsPainlessExecute = require('./_core/scriptsPainlessExecute').bind(this)
+    this.scroll = require('./_core/scroll').bind(this)
+    this.search = require('./_core/search').bind(this)
+    this.searchShards = require('./_core/searchShards').bind(this)
+    this.searchTemplate = require('./_core/searchTemplate').bind(this)
+    this.termvectors = require('./_core/termvectors').bind(this)
+    this.update = require('./_core/update').bind(this)
+    this.updateByQuery = require('./_core/updateByQuery').bind(this)
+    this.updateByQueryRethrottle = require('./_core/updateByQueryRethrottle').bind(this)
+
+    // Deprecated: Use clearScroll instead.
+    this.clear_scroll = require('./_core/clearScroll').bind(this)
+    // Deprecated: Use createPit instead.
+    this.create_pit = require('./_core/createPit').bind(this)
+    // Deprecated: Use deleteAllPits instead.
+    this.delete_all_pits = require('./_core/deleteAllPits').bind(this)
+    // Deprecated: Use deleteByQuery instead.
+    this.delete_by_query = require('./_core/deleteByQuery').bind(this)
+    // Deprecated: Use deleteByQueryRethrottle instead.
+    this.delete_by_query_rethrottle = require('./_core/deleteByQueryRethrottle').bind(this)
+    // Deprecated: Use deletePit instead.
+    this.delete_pit = require('./_core/deletePit').bind(this)
+    // Deprecated: Use deleteScript instead.
+    this.delete_script = require('./_core/deleteScript').bind(this)
+    // Deprecated: Use existsSource instead.
+    this.exists_source = require('./_core/existsSource').bind(this)
+    // Deprecated: Use fieldCaps instead.
+    this.field_caps = require('./_core/fieldCaps').bind(this)
+    // Deprecated: Use getAllPits instead.
+    this.get_all_pits = require('./_core/getAllPits').bind(this)
+    // Deprecated: Use getScript instead.
+    this.get_script = require('./_core/getScript').bind(this)
+    // Deprecated: Use getScriptContext instead.
+    this.get_script_context = require('./_core/getScriptContext').bind(this)
+    // Deprecated: Use getScriptLanguages instead.
+    this.get_script_languages = require('./_core/getScriptLanguages').bind(this)
+    // Deprecated: Use getSource instead.
+    this.get_source = require('./_core/getSource').bind(this)
+    // Deprecated: Use msearchTemplate instead.
+    this.msearch_template = require('./_core/msearchTemplate').bind(this)
+    // Deprecated: Use putScript instead.
+    this.put_script = require('./_core/putScript').bind(this)
+    // Deprecated: Use rankEval instead.
+    this.rank_eval = require('./_core/rankEval').bind(this)
+    // Deprecated: Use reindexRethrottle instead.
+    this.reindex_rethrottle = require('./_core/reindexRethrottle').bind(this)
+    // Deprecated: Use renderSearchTemplate instead.
+    this.render_search_template = require('./_core/renderSearchTemplate').bind(this)
+    // Deprecated: Use scriptsPainlessExecute instead.
+    this.scripts_painless_execute = require('./_core/scriptsPainlessExecute').bind(this)
+    // Deprecated: Use searchShards instead.
+    this.search_shards = require('./_core/searchShards').bind(this)
+    // Deprecated: Use searchTemplate instead.
+    this.search_template = require('./_core/searchTemplate').bind(this)
+    // Deprecated: Use updateByQuery instead.
+    this.update_by_query = require('./_core/updateByQuery').bind(this)
+    // Deprecated: Use updateByQueryRethrottle instead.
+    this.update_by_query_rethrottle = require('./_core/updateByQueryRethrottle').bind(this)
+
+    // Setup API Modules
+    Object.defineProperties(this, {
+      asynchronousSearch: { get() { return this[kApiModules].asynchronousSearch } },
+      cat: { get() { return this[kApiModules].cat } },
+      cluster: { get() { return this[kApiModules].cluster } },
+      danglingIndices: { get() { return this[kApiModules].danglingIndices } },
+      flowFramework: { get() { return this[kApiModules].flowFramework } },
+      http: { get() { return this[kApiModules].http } },
+      indices: { get() { return this[kApiModules].indices } },
+      ingest: { get() { return this[kApiModules].ingest } },
+      ism: { get() { return this[kApiModules].ism } },
+      knn: { get() { return this[kApiModules].knn } },
+      ml: { get() { return this[kApiModules].ml } },
+      nodes: { get() { return this[kApiModules].nodes } },
+      notifications: { get() { return this[kApiModules].notifications } },
+      observability: { get() { return this[kApiModules].observability } },
+      ppl: { get() { return this[kApiModules].ppl } },
+      query: { get() { return this[kApiModules].query } },
+      remoteStore: { get() { return this[kApiModules].remoteStore } },
+      rollups: { get() { return this[kApiModules].rollups } },
+      searchPipeline: { get() { return this[kApiModules].searchPipeline } },
+      security: { get() { return this[kApiModules].security } },
+      snapshot: { get() { return this[kApiModules].snapshot } },
+      sql: { get() { return this[kApiModules].sql } },
+      tasks: { get() { return this[kApiModules].tasks } },
+      transforms: { get() { return this[kApiModules].transforms } },
+
+      // Deprecated: Use asynchronousSearch instead.
+      asynchronous_search: { get() { return this[kApiModules].asynchronousSearch } },
+      // Deprecated: Use danglingIndices instead.
+      dangling_indices: { get() { return this[kApiModules].danglingIndices } },
+      // Deprecated: Use flowFramework instead.
+      flow_framework: { get() { return this[kApiModules].flowFramework } },
+      // Deprecated: Use remoteStore instead.
+      remote_store: { get() { return this[kApiModules].remoteStore } },
+      // Deprecated: Use searchPipeline instead.
+      search_pipeline: { get() { return this[kApiModules].searchPipeline } },
+    })
+  }
+}
+
+module.exports = OpenSearchAPI;
diff --git a/api/_types/_common.d.ts b/api/_types/_common.d.ts
index f30168ed9..829920c24 100644
--- a/api/_types/_common.d.ts
+++ b/api/_types/_common.d.ts
@@ -341,7 +341,9 @@ export interface KnnField {
   filter?: Common_QueryDsl.QueryContainer | Common_QueryDsl.QueryContainer[];
   k?: number;
   max_distance?: number;
+  method_parameters?: Record<string, number>;
   min_score?: number;
+  rescore?: Record<string, number>;
   vector: QueryVector;
 }
 
diff --git a/api/_types/_common.mapping.d.ts b/api/_types/_common.mapping.d.ts
index bfbd7b7e4..539e759a6 100644
--- a/api/_types/_common.mapping.d.ts
+++ b/api/_types/_common.mapping.d.ts
@@ -299,8 +299,12 @@ export interface KnnVectorProperty extends KnnVectorPropertyBase {
 }
 
 export interface KnnVectorPropertyBase {
+  compression_level?: string;
+  data_type?: string;
   dimension: number;
   method?: KnnVectorMethod;
+  mode?: string;
+  space_type?: string;
 }
 
 export interface LongNumberProperty extends NumberPropertyBase {
diff --git a/api/knn/trainModel.d.ts b/api/knn/trainModel.d.ts
index 620f18364..74f4700f6 100644
--- a/api/knn/trainModel.d.ts
+++ b/api/knn/trainModel.d.ts
@@ -24,11 +24,14 @@ export interface Knn_TrainModel_Request extends Global.Params {
 }
 
 export interface Knn_TrainModel_RequestBody {
+  compression_level?: string;
   description?: string;
   dimension: number;
   max_training_vector_count?: number;
-  method: string;
+  method?: string;
+  mode?: string;
   search_size?: number;
+  spaceType?: string;
   training_field: string;
   training_index: string;
 }
@@ -37,5 +40,7 @@ export interface Knn_TrainModel_Response extends ApiResponse {
   body: Knn_TrainModel_ResponseBody;
 }
 
-export type Knn_TrainModel_ResponseBody = Record<string, any>
+export interface Knn_TrainModel_ResponseBody {
+  model_id: string;
+}