elasticsearch-store 0.63.2 → 0.64.0

package/dist/src/elasticsearch-client/client.d.ts

@@ -0,0 +1,233 @@
+import { ClientParams, ClientResponse, ClientMetadata } from '@terascope/types';
+export declare class Client {
+    private client;
+    private distributionMeta;
+    constructor(client: any, distributionMeta: ClientMetadata);
+    get __meta(): ClientMetadata;
+    bulk(params: ClientParams.BulkParams): Promise<ClientResponse.BulkResponse>;
+    /**
+     * creates a new record, can throw if record already exists
+     * @param CountParams
+    */
+    create(params: ClientParams.CreateParams): Promise<ClientResponse.CreateResponse>;
+    /**
+     * indexes a new record
+     * @param CountParams
+    */
+    index(params: ClientParams.IndexParams): Promise<ClientResponse.IndexResponse>;
+    /**
+     * updates a record, or can upsert a record
+     * @param CountParams
+    */
+    update(params: ClientParams.UpdateParams): Promise<ClientResponse.UpdateResponse>;
+    /**
+     * Gets the number of matches for a search query or
+     * if no query provided the count for docs in an index
+     * @param CountParams
+    */
+    count(params: ClientParams.CountParams): Promise<ClientResponse.CountResponse>;
+    get cluster(): {
+        getSettings(params?: ClientParams.ClusterGetSettingsParams): Promise<ClientResponse.ClusterGetSettingsResponse>;
+        health(params?: ClientParams.ClusterHealthParams): Promise<ClientResponse.ClusterHealthResponse>;
+    };
+    get cat(): {
+        indices(params?: ClientParams.CatIndicesParams): Promise<ClientResponse.CatIndicesResponse>;
+    };
+    get nodes(): {
+        stats(params?: ClientParams.NodesStatsParams): Promise<ClientResponse.NodesStatsResponse>;
+        info(params?: ClientParams.NodesInfoParams): Promise<ClientResponse.NodesInfoResponse>;
+    };
+    /**
+     * Deletes a specific record, requires an index and id.
+     * @param RequestParams.delete
+    */
+    delete(params: ClientParams.DeleteParams): Promise<ClientResponse.DeleteResponse>;
+    /**
+     * Deletes documents that match the specified query.
+     * @param RequestParams.DeleteByQuery
+     * @returns count or Elasticsearch task_id
+    */
+    deleteByQuery(params: ClientParams.DeleteByQueryParams): Promise<ClientResponse.DeleteByQueryResponse>;
+    /**
+     * Check that the document id exists in the specified index.
+     * @param ExistsParams
+     * @returns boolean
+    */
+    exists(params: ClientParams.ExistsParams): Promise<ClientResponse.ExistsResponse>;
+    /**
+     * Retrieves the specified JSON document from an index or an empty doc if no doc id is found
+     * @param ClientParams.GetParams
+     * @returns Object
+    */
+    get<T = Record<string, unknown>>(params: ClientParams.GetParams): Promise<ClientResponse.GetResponse<T>>;
+    /**
+     * Returns info about the cluster the client is connected to
+     * @returns object with cluster info
+    */
+    info(): Promise<ClientResponse.InfoResponse>;
+    /**
+     * Returns true or false based on whether the cluster is running.
+     * @returns Boolean
+    */
+    ping(): Promise<boolean>;
+    /**
+     * Returns search hits that match the query defined in the request.
+     * @param SearchParams
+     * @returns Array of Record<string, any>
+    */
+    search<T = Record<string, unknown>>(params: ClientParams.SearchParams): Promise<ClientResponse.SearchResponse<T>>;
+    /**
+     * The multi search execution of several searches within the same API request
+     * @param MSearchParams
+     * @returns Array of Record<string, any>
+    */
+    msearch(params: ClientParams.MSearchParams): Promise<ClientResponse.MSearchResponse>;
+    /**
+     * The multi get execution of multiple-get searches from a single API request
+     * @param MGetParams
+     * @returns Array of Record<string, any>
+    */
+    mget(params: ClientParams.MGetParams): Promise<ClientResponse.MGetResponse>;
+    /**
+     * Re-Index data to a new index
+     * @param ReIndexParams
+     * @returns Report of re-indexing task or task id if wait_for_completion is false
+    */
+    reindex(params: ClientParams.ReindexParams): Promise<ClientResponse.ReindexResponse>;
+    get indices(): {
+        /**
+         * Creates a new index.
+         * @param IndicesCreateParams
+         * @returns IndicesCreateResponse
+         */
+        create(params: ClientParams.IndicesCreateParams): Promise<ClientResponse.IndicesCreateResponse>;
+        /**
+         * Deletes one or more indices.
+         * @param IndicesDeleteParams
+         * @returns
+         */
+        delete(params: ClientParams.IndicesDeleteParams): Promise<ClientResponse.IndicesDeleteResponse>;
+        /**
+         * Checks if a data stream, index, or alias exists.
+         * @param IndicesExistsParams
+         * @returns boolean
+         */
+        exists(params: ClientParams.IndicesExistsParams): Promise<ClientResponse.IndicesExistsResponse>;
+        /**
+         * Returns information about one or more indices
+         * @param IndicesGetParams
+         * @returns
+        */
+        get(params: ClientParams.IndicesGetParams): Promise<ClientResponse.IndicesGetResponse>;
+        /**
+         * Uploads index mapping template
+         * @param IndicesPutTemplateParams
+         * @returns IndicesPutTemplateResponse
+        */
+        putTemplate(params: ClientParams.IndicesPutTemplateParams): Promise<ClientResponse.IndicesPutTemplateResponse>;
+        /**
+         * Deletes index templates
+         * @param IndicesDeleteTemplateParams
+         * @returns IndicesDeleteTemplateResponse
+        */
+        deleteTemplate(params: ClientParams.IndicesDeleteTemplateParams): Promise<ClientResponse.IndicesDeleteTemplateResponse>;
+        /**
+         * Returns true if template exists
+         * @param IndicesExistsTemplateParams
+         * @returns boolean
+         */
+        existsTemplate(params: ClientParams.IndicesExistsTemplateParams): Promise<ClientResponse.IndicesExistsTemplateResponse>;
+        /**
+         * Returns template
+         * @param IndicesGetTemplateParams
+         * @returns template
+        */
+        getTemplate(params: ClientParams.IndicesGetTemplateParams): Promise<ClientResponse.IndicesGetTemplateResponse>;
+        /**
+         * Returns index template
+         * @param IndicesGetIndexTemplateParams
+         * @returns IndicesGetIndexTemplateResponse
+         * not supported by elasticsearch version 6
+         * same params as IndicesGetTemplateParams
+        */
+        getIndexTemplate(params: ClientParams.IndicesGetIndexTemplateParams): Promise<ClientResponse.IndicesGetIndexTemplateResponse>;
+        /**
+         * Retrieves mapping definitions for one or more indices
+         * @param IndicesGetMappingParams
+         * @returns IndicesGetMappingResponse
+        */
+        getMapping(params: ClientParams.IndicesGetMappingParams): Promise<ClientResponse.IndicesGetMappingResponse>;
+        /**
+         * Adds new fields to an existing index or edit the search settings of existing fields.
+         * @param IndicesPutMappingParams
+         * @returns IndicesPutMappingResponse
+        */
+        putMapping(params: ClientParams.IndicesPutMappingParams): Promise<ClientResponse.IndicesPutMappingResponse>;
+        /**
+         * Retrieves mapping definitions for one or more fields.
+         * @param IndicesGetFieldMappingParams
+         * @response IndicesGetFieldMappingResponse
+        */
+        getFieldMapping(params: ClientParams.IndicesGetFieldMappingParams): Promise<ClientResponse.IndicesGetFieldMappingResponse>;
+        /**
+         * Returns setting information for one or more indices
+         * @param IndicesGetSettingsParams
+         * @returns IndicesGetSettingsResponse
+         */
+        getSettings(params: ClientParams.IndicesGetSettingsParams): Promise<ClientResponse.IndicesGetSettingsResponse>;
+        /**
+         * Changes a dynamic index setting in real time.
+         * @param IndicesPutSettingsParams
+         * @returns IndicesPutSettingsResponse
+        */
+        putSettings(params: ClientParams.IndicesPutSettingsParams): Promise<ClientResponse.IndicesPutSettingsResponse>;
+        /**
+         * Makes a recent operation performed on one or more indices available for search.
+         * @param IndicesRefreshParams
+         * @returns IndicesRefreshResponse
+         * can be an empty query
+        */
+        refresh(params: ClientParams.IndicesRefreshParams): Promise<ClientResponse.IndicesRefreshResponse>;
+        /**
+         * Returns information about shard recoveries for one or more indices
+         * @param IndicesRecoveryParams
+         * @returns IndicesRecoveryResponse
+         * can be an empty query
+        */
+        recovery(params: ClientParams.IndicesRecoveryParams): Promise<ClientResponse.IndicesRecoveryResponse>;
+        /**
+         * Validates a query without executing it.
+         * @param IndicesValidateQueryParams
+         * @returns IndicesValidateQueryResponse
+        */
+        validateQuery(params: ClientParams.IndicesValidateQueryParams): Promise<ClientResponse.IndicesValidateQueryResponse>;
+        /**
+         * Returns statistics for one or more indices
+         * @param IndicesStatsParams
+         * @returns IndicesStatsResponse
+        */
+        stats(params: ClientParams.IndicesStats): Promise<ClientResponse.IndicesStatsResponse>;
+    };
+    get tasks(): {
+        /**
+         * Cancels a currently running task
+         * @param TasksCancelParams
+         * @returns TasksCancelResponse
+        */
+        cancel(params: ClientParams.TasksCancelParams): Promise<ClientResponse.TasksCancelResponse>;
+        /**
+         * Gets information about a running task
+         * @param TasksGetParams
+         * @returns TasksGetResponse
+        */
+        get(params: ClientParams.TasksGetParams): Promise<ClientResponse.TasksGetResponse>;
+        /**
+         * Returns information about the tasks currently executing in the cluster.
+         * @param TasksListParams
+         * @returns TasksListResponse
+        */
+        list(params: ClientParams.TasksListParams): Promise<ClientResponse.TasksListResponse>;
+    };
+    private _removeBody;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/src/elasticsearch-client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/elasticsearch-client/client.ts"],"names":[],"mappings":"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"}

package/dist/src/elasticsearch-client/client.js

@@ -0,0 +1,446 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const methods = __importStar(require("./method-helpers"));
+class Client {
+    constructor(client, distributionMeta) {
+        this.client = client;
+        this.distributionMeta = distributionMeta;
+    }
+    get __meta() {
+        return this.distributionMeta;
+    }
+    async bulk(params) {
+        const parsedParams = methods.convertBulkParams(params, this.distributionMeta);
+        const resp = await this.client.bulk(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * creates a new record, can throw if record already exists
+     * @param CountParams
+    */
+    async create(params) {
+        const parsedParams = methods.convertCreateParams(params, this.distributionMeta);
+        const resp = await this.client.create(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * indexes a new record
+     * @param CountParams
+    */
+    async index(params) {
+        const parsedParams = methods.convertIndexParams(params, this.distributionMeta);
+        const resp = await this.client.index(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * updates a record, or can upsert a record
+     * @param CountParams
+    */
+    async update(params) {
+        const parsedParams = methods.convertUpdateParams(params, this.distributionMeta);
+        const resp = await this.client.update(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * Gets the number of matches for a search query or
+     * if no query provided the count for docs in an index
+     * @param CountParams
+    */
+    async count(params) {
+        const parsedParams = methods.convertCountParams(params, this.distributionMeta);
+        const resp = await this.client.count(parsedParams);
+        return this._removeBody(resp);
+    }
+    get cluster() {
+        const { distributionMeta, client, _removeBody } = this;
+        return {
+            async getSettings(params = {}) {
+                const parsedParams = methods.convertClusterSettingsParams(params, distributionMeta);
+                const resp = await client.cluster.getSettings(parsedParams);
+                return _removeBody(resp);
+            },
+            async health(params = {}) {
+                const parsedParams = methods.convertClusterSettingsParams(params, distributionMeta);
+                const resp = await client.cluster.health(parsedParams);
+                return _removeBody(resp);
+            }
+        };
+    }
+    get cat() {
+        const { distributionMeta, client, _removeBody } = this;
+        return {
+            async indices(params = {}) {
+                const parsedParams = methods.convertCatIndicesParams(params, distributionMeta);
+                const resp = await client.cat.indices(parsedParams);
+                return _removeBody(resp);
+            }
+        };
+    }
+    get nodes() {
+        const { distributionMeta, client, _removeBody } = this;
+        return {
+            async stats(params = {}) {
+                const parsedParams = methods.convertNodesStatsParams(params, distributionMeta);
+                const resp = await client.nodes.stats(parsedParams);
+                return _removeBody(resp);
+            },
+            async info(params = {}) {
+                const parsedParams = methods.convertNodeInfoParams(params, distributionMeta);
+                const resp = await client.nodes.info(parsedParams);
+                return _removeBody(resp);
+            }
+        };
+    }
+    /**
+     * Deletes a specific record, requires an index and id.
+     * @param RequestParams.delete
+    */
+    async delete(params) {
+        const parsedParams = methods.convertDeleteParams(params, this.distributionMeta);
+        const resp = await this.client.delete(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * Deletes documents that match the specified query.
+     * @param RequestParams.DeleteByQuery
+     * @returns count or Elasticsearch task_id
+    */
+    async deleteByQuery(params) {
+        const parsedParams = methods.convertDeleteByQueryParams(params, this.distributionMeta);
+        const resp = await this.client.deleteByQuery(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * Check that the document id exists in the specified index.
+     * @param ExistsParams
+     * @returns boolean
+    */
+    async exists(params) {
+        const convertedParams = methods.convertExistsParams(params, this.distributionMeta);
+        const resp = await this.client.exists(convertedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * Retrieves the specified JSON document from an index or an empty doc if no doc id is found
+     * @param ClientParams.GetParams
+     * @returns Object
+    */
+    async get(params) {
+        const parsedParams = methods.convertGetParams(params, this.distributionMeta);
+        const response = await this.client.get(parsedParams);
+        return this._removeBody(response);
+    }
+    /**
+     * Returns info about the cluster the client is connected to
+     * @returns object with cluster info
+    */
+    async info() {
+        methods.validateDistribution(this.distributionMeta);
+        const resp = await this.client.info();
+        return this._removeBody(resp);
+    }
+    /**
+     * Returns true or false based on whether the cluster is running.
+     * @returns Boolean
+    */
+    async ping() {
+        methods.validateDistribution(this.distributionMeta);
+        const resp = await this.client.ping();
+        return this._removeBody(resp);
+    }
+    /**
+     * Returns search hits that match the query defined in the request.
+     * @param SearchParams
+     * @returns Array of Record<string, any>
+    */
+    async search(params) {
+        const parsedParams = methods.convertSearchParams(params, this.distributionMeta);
+        const resp = await this.client.search(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * The multi search execution of several searches within the same API request
+     * @param MSearchParams
+     * @returns Array of Record<string, any>
+    */
+    async msearch(params) {
+        const parsedParams = methods.convertMSearchParams(params, this.distributionMeta);
+        const resp = await this.client.msearch(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * The multi get execution of multiple-get searches from a single API request
+     * @param MGetParams
+     * @returns Array of Record<string, any>
+    */
+    async mget(params) {
+        const parsedParams = methods.convertMGetParams(params, this.distributionMeta);
+        const resp = await this.client.mget(parsedParams);
+        return this._removeBody(resp);
+    }
+    /**
+     * Re-Index data to a new index
+     * @param ReIndexParams
+     * @returns Report of re-indexing task or task id if wait_for_completion is false
+    */
+    async reindex(params) {
+        const parsedParams = methods.convertReIndexParams(params, this.distributionMeta);
+        const resp = await this.client.reindex(parsedParams);
+        return this._removeBody(resp);
+    }
+    get indices() {
+        const { distributionMeta, client, _removeBody } = this;
+        return {
+            /**
+             * Creates a new index.
+             * @param IndicesCreateParams
+             * @returns IndicesCreateResponse
+             */
+            async create(params) {
+                const parsedParams = methods.convertIndicesCreateParams(params, distributionMeta);
+                const resp = await client.indices.create(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Deletes one or more indices.
+             * @param IndicesDeleteParams
+             * @returns
+             */
+            async delete(params) {
+                const parsedParams = methods.convertIndicesDeleteParams(params, distributionMeta);
+                const resp = await client.indices.delete(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Checks if a data stream, index, or alias exists.
+             * @param IndicesExistsParams
+             * @returns boolean
+             */
+            async exists(params) {
+                const parsedParams = methods.convertIndicesExistsParams(params, distributionMeta);
+                const resp = await client.indices.exists(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns information about one or more indices
+             * @param IndicesGetParams
+             * @returns
+            */
+            async get(params) {
+                const parsedParams = methods.convertIndicesGetParams(params, distributionMeta);
+                const resp = await client.indices.get(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Uploads index mapping template
+             * @param IndicesPutTemplateParams
+             * @returns IndicesPutTemplateResponse
+            */
+            async putTemplate(params) {
+                const parsedParams = methods.convertIndicesPutTemplateParams(params, distributionMeta);
+                const resp = await client.indices.putTemplate(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Deletes index templates
+             * @param IndicesDeleteTemplateParams
+             * @returns IndicesDeleteTemplateResponse
+            */
+            async deleteTemplate(params) {
+                const parsedParams = methods.convertIndicesDeleteTemplateParams(params, distributionMeta);
+                const resp = await client.indices.deleteTemplate(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns true if template exists
+             * @param IndicesExistsTemplateParams
+             * @returns boolean
+             */
+            async existsTemplate(params) {
+                const parsedParams = methods.convertIndicesExistsTemplateParams(params, distributionMeta);
+                const resp = await client.indices.existsTemplate(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns template
+             * @param IndicesGetTemplateParams
+             * @returns template
+            */
+            async getTemplate(params) {
+                const parsedParams = methods.convertIndicesGetTemplateParams(params, distributionMeta);
+                const resp = await client.indices.getTemplate(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns index template
+             * @param IndicesGetIndexTemplateParams
+             * @returns IndicesGetIndexTemplateResponse
+             * not supported by elasticsearch version 6
+             * same params as IndicesGetTemplateParams
+            */
+            async getIndexTemplate(params) {
+                const parsedParams = methods.convertIndicesGetIndexTemplateParams(params, distributionMeta);
+                const resp = await client.indices.getIndexTemplate(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Retrieves mapping definitions for one or more indices
+             * @param IndicesGetMappingParams
+             * @returns IndicesGetMappingResponse
+            */
+            async getMapping(params) {
+                const parsedParams = methods.convertIndicesGetMappingParams(params, distributionMeta);
+                const resp = await client.indices.getMapping(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Adds new fields to an existing index or edit the search settings of existing fields.
+             * @param IndicesPutMappingParams
+             * @returns IndicesPutMappingResponse
+            */
+            async putMapping(params) {
+                const parsedParams = methods.convertIndicesPutMappingParams(params, distributionMeta);
+                const resp = await client.indices.putMapping(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Retrieves mapping definitions for one or more fields.
+             * @param IndicesGetFieldMappingParams
+             * @response IndicesGetFieldMappingResponse
+            */
+            async getFieldMapping(params) {
+                const parsedParams = methods.convertIndicesGetFieldMappingParams(params, distributionMeta);
+                const resp = await client.indices.getSettings(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns setting information for one or more indices
+             * @param IndicesGetSettingsParams
+             * @returns IndicesGetSettingsResponse
+             */
+            async getSettings(params) {
+                const parsedParams = methods.convertIndicesGetSettingsParams(params, distributionMeta);
+                const resp = await client.indices.getSettings(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Changes a dynamic index setting in real time.
+             * @param IndicesPutSettingsParams
+             * @returns IndicesPutSettingsResponse
+            */
+            async putSettings(params) {
+                const parsedParams = methods.convertIndicesPutSettingsParams(params, distributionMeta);
+                const resp = await client.indices.putSettings(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Makes a recent operation performed on one or more indices available for search.
+             * @param IndicesRefreshParams
+             * @returns IndicesRefreshResponse
+             * can be an empty query
+            */
+            async refresh(params) {
+                const parsedParams = methods.convertIndicesRefreshParams(params, distributionMeta);
+                const resp = await client.indices.refresh(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns information about shard recoveries for one or more indices
+             * @param IndicesRecoveryParams
+             * @returns IndicesRecoveryResponse
+             * can be an empty query
+            */
+            async recovery(params) {
+                const parsedParams = methods.convertIndicesRecoveryParams(params, distributionMeta);
+                const resp = await client.indices.recovery(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Validates a query without executing it.
+             * @param IndicesValidateQueryParams
+             * @returns IndicesValidateQueryResponse
+            */
+            async validateQuery(params) {
+                const parsedParams = methods.convertIndicesValidateQueryParams(params, distributionMeta);
+                const resp = await client.indices.validateQuery(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns statistics for one or more indices
+             * @param IndicesStatsParams
+             * @returns IndicesStatsResponse
+            */
+            async stats(params) {
+                const parsedParams = methods.convertIndicesStatsParams(params, distributionMeta);
+                const resp = await client.indices.stats(parsedParams);
+                return _removeBody(resp);
+            }
+        };
+    }
+    get tasks() {
+        const { distributionMeta, client, _removeBody, } = this;
+        return {
+            /**
+             * Cancels a currently running task
+             * @param TasksCancelParams
+             * @returns TasksCancelResponse
+            */
+            async cancel(params) {
+                const parsedParams = methods.convertTasksCancelParams(params, distributionMeta);
+                const resp = await client.tasks.cancel(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Gets information about a running task
+             * @param TasksGetParams
+             * @returns TasksGetResponse
+            */
+            async get(params) {
+                const parsedParams = methods.convertTasksGetParams(params, distributionMeta);
+                const resp = await client.tasks.get(parsedParams);
+                return _removeBody(resp);
+            },
+            /**
+             * Returns information about the tasks currently executing in the cluster.
+             * @param TasksListParams
+             * @returns TasksListResponse
+            */
+            async list(params) {
+                const parsedParams = methods.convertTasksListParams(params, distributionMeta);
+                const resp = await client.tasks.list(parsedParams);
+                return _removeBody(resp);
+            }
+        };
+    }
+    _removeBody(input) {
+        if (input.body == null)
+            return input;
+        return input.body;
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=client.js.map