@datadog/datadog-api-client 1.16.0 → 1.18.0

package/dist/packages/datadog-api-client-v2/apis/APMRetentionFiltersApi.d.ts

@@ -0,0 +1,143 @@
+import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi";
+import { Configuration } from "../../datadog-api-client-common/configuration";
+import { RequestContext, ResponseContext } from "../../datadog-api-client-common/http/http";
+import { ReorderRetentionFiltersRequest } from "../models/ReorderRetentionFiltersRequest";
+import { RetentionFilterCreateRequest } from "../models/RetentionFilterCreateRequest";
+import { RetentionFilterResponse } from "../models/RetentionFilterResponse";
+import { RetentionFiltersResponse } from "../models/RetentionFiltersResponse";
+import { RetentionFilterUpdateRequest } from "../models/RetentionFilterUpdateRequest";
+export declare class APMRetentionFiltersApiRequestFactory extends BaseAPIRequestFactory {
+    createApmRetentionFilter(body: RetentionFilterCreateRequest, _options?: Configuration): Promise<RequestContext>;
+    deleteApmRetentionFilter(filterId: string, _options?: Configuration): Promise<RequestContext>;
+    getApmRetentionFilter(filterId: string, _options?: Configuration): Promise<RequestContext>;
+    listApmRetentionFilters(_options?: Configuration): Promise<RequestContext>;
+    reorderApmRetentionFilters(body: ReorderRetentionFiltersRequest, _options?: Configuration): Promise<RequestContext>;
+    updateApmRetentionFilter(filterId: string, body: RetentionFilterUpdateRequest, _options?: Configuration): Promise<RequestContext>;
+}
+export declare class APMRetentionFiltersApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createApmRetentionFilter(response: ResponseContext): Promise<RetentionFilterResponse>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteApmRetentionFilter(response: ResponseContext): Promise<void>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getApmRetentionFilter(response: ResponseContext): Promise<RetentionFilterResponse>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to listApmRetentionFilters
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listApmRetentionFilters(response: ResponseContext): Promise<RetentionFiltersResponse>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to reorderApmRetentionFilters
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    reorderApmRetentionFilters(response: ResponseContext): Promise<void>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to updateApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateApmRetentionFilter(response: ResponseContext): Promise<RetentionFilterResponse>;
+}
+export interface APMRetentionFiltersApiCreateApmRetentionFilterRequest {
+    /**
+     * The definition of the new retention filter.
+     * @type RetentionFilterCreateRequest
+     */
+    body: RetentionFilterCreateRequest;
+}
+export interface APMRetentionFiltersApiDeleteApmRetentionFilterRequest {
+    /**
+     * The ID of the retention filter.
+     * @type string
+     */
+    filterId: string;
+}
+export interface APMRetentionFiltersApiGetApmRetentionFilterRequest {
+    /**
+     * The ID of the retention filter.
+     * @type string
+     */
+    filterId: string;
+}
+export interface APMRetentionFiltersApiReorderApmRetentionFiltersRequest {
+    /**
+     * The list of retention filters in the new order.
+     * @type ReorderRetentionFiltersRequest
+     */
+    body: ReorderRetentionFiltersRequest;
+}
+export interface APMRetentionFiltersApiUpdateApmRetentionFilterRequest {
+    /**
+     * The ID of the retention filter.
+     * @type string
+     */
+    filterId: string;
+    /**
+     * The updated definition of the retention filter.
+     * @type RetentionFilterUpdateRequest
+     */
+    body: RetentionFilterUpdateRequest;
+}
+export declare class APMRetentionFiltersApi {
+    private requestFactory;
+    private responseProcessor;
+    private configuration;
+    constructor(configuration: Configuration, requestFactory?: APMRetentionFiltersApiRequestFactory, responseProcessor?: APMRetentionFiltersApiResponseProcessor);
+    /**
+     * Create a retention filter to index spans in your organization.
+     * Returns the retention filter definition when the request is successful.
+     * @param param The request object
+     */
+    createApmRetentionFilter(param: APMRetentionFiltersApiCreateApmRetentionFilterRequest, options?: Configuration): Promise<RetentionFilterResponse>;
+    /**
+     * Delete a specific retention filter from your organization.
+     * @param param The request object
+     */
+    deleteApmRetentionFilter(param: APMRetentionFiltersApiDeleteApmRetentionFilterRequest, options?: Configuration): Promise<void>;
+    /**
+     * Get an APM retention filter.
+     * @param param The request object
+     */
+    getApmRetentionFilter(param: APMRetentionFiltersApiGetApmRetentionFilterRequest, options?: Configuration): Promise<RetentionFilterResponse>;
+    /**
+     * Get the list of APM retention filters.
+     * @param param The request object
+     */
+    listApmRetentionFilters(options?: Configuration): Promise<RetentionFiltersResponse>;
+    /**
+     * Re-order the execution order of retention filters.
+     * @param param The request object
+     */
+    reorderApmRetentionFilters(param: APMRetentionFiltersApiReorderApmRetentionFiltersRequest, options?: Configuration): Promise<void>;
+    /**
+     * Update a retention filter from your organization.
+     * @param param The request object
+     */
+    updateApmRetentionFilter(param: APMRetentionFiltersApiUpdateApmRetentionFilterRequest, options?: Configuration): Promise<RetentionFilterResponse>;
+}

package/dist/packages/datadog-api-client-v2/apis/APMRetentionFiltersApi.js

@@ -0,0 +1,499 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APMRetentionFiltersApi = exports.APMRetentionFiltersApiResponseProcessor = exports.APMRetentionFiltersApiRequestFactory = void 0;
+const baseapi_1 = require("../../datadog-api-client-common/baseapi");
+const configuration_1 = require("../../datadog-api-client-common/configuration");
+const http_1 = require("../../datadog-api-client-common/http/http");
+const logger_1 = require("../../../logger");
+const ObjectSerializer_1 = require("../models/ObjectSerializer");
+const exception_1 = require("../../datadog-api-client-common/exception");
+class APMRetentionFiltersApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    createApmRetentionFilter(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createApmRetentionFilter");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/apm/config/retention-filters";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.APMRetentionFiltersApi.createApmRetentionFilter")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "RetentionFilterCreateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    deleteApmRetentionFilter(filterId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'filterId' is not null or undefined
+            if (filterId === null || filterId === undefined) {
+                throw new baseapi_1.RequiredError("filterId", "deleteApmRetentionFilter");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/apm/config/retention-filters/{filter_id}".replace("{filter_id}", encodeURIComponent(String(filterId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.APMRetentionFiltersApi.deleteApmRetentionFilter")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getApmRetentionFilter(filterId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'filterId' is not null or undefined
+            if (filterId === null || filterId === undefined) {
+                throw new baseapi_1.RequiredError("filterId", "getApmRetentionFilter");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/apm/config/retention-filters/{filter_id}".replace("{filter_id}", encodeURIComponent(String(filterId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.APMRetentionFiltersApi.getApmRetentionFilter")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listApmRetentionFilters(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // Path Params
+            const localVarPath = "/api/v2/apm/config/retention-filters";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.APMRetentionFiltersApi.listApmRetentionFilters")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    reorderApmRetentionFilters(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "reorderApmRetentionFilters");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/apm/config/retention-filters-execution-order";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.APMRetentionFiltersApi.reorderApmRetentionFilters")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PUT);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "ReorderRetentionFiltersRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateApmRetentionFilter(filterId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'filterId' is not null or undefined
+            if (filterId === null || filterId === undefined) {
+                throw new baseapi_1.RequiredError("filterId", "updateApmRetentionFilter");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateApmRetentionFilter");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/apm/config/retention-filters/{filter_id}".replace("{filter_id}", encodeURIComponent(String(filterId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.APMRetentionFiltersApi.updateApmRetentionFilter")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PUT);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "RetentionFilterUpdateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+}
+exports.APMRetentionFiltersApiRequestFactory = APMRetentionFiltersApiRequestFactory;
+class APMRetentionFiltersApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createApmRetentionFilter(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFilterResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 400 ||
+                response.httpStatusCode == 403 ||
+                response.httpStatusCode == 409 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFilterResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteApmRetentionFilter(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                return;
+            }
+            if (response.httpStatusCode == 403 ||
+                response.httpStatusCode == 404 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getApmRetentionFilter(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFilterResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 403 ||
+                response.httpStatusCode == 404 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFilterResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to listApmRetentionFilters
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listApmRetentionFilters(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFiltersResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 403 || response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFiltersResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to reorderApmRetentionFilters
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    reorderApmRetentionFilters(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                return;
+            }
+            if (response.httpStatusCode == 400 ||
+                response.httpStatusCode == 403 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to updateApmRetentionFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateApmRetentionFilter(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode == 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFilterResponse");
+                return body;
+            }
+            if (response.httpStatusCode == 400 ||
+                response.httpStatusCode == 403 ||
+                response.httpStatusCode == 404 ||
+                response.httpStatusCode == 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.info(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "RetentionFilterResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+}
+exports.APMRetentionFiltersApiResponseProcessor = APMRetentionFiltersApiResponseProcessor;
+class APMRetentionFiltersApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.configuration = configuration;
+        this.requestFactory =
+            requestFactory || new APMRetentionFiltersApiRequestFactory(configuration);
+        this.responseProcessor =
+            responseProcessor || new APMRetentionFiltersApiResponseProcessor();
+    }
+    /**
+     * Create a retention filter to index spans in your organization.
+     * Returns the retention filter definition when the request is successful.
+     * @param param The request object
+     */
+    createApmRetentionFilter(param, options) {
+        const requestContextPromise = this.requestFactory.createApmRetentionFilter(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createApmRetentionFilter(responseContext);
+            });
+        });
+    }
+    /**
+     * Delete a specific retention filter from your organization.
+     * @param param The request object
+     */
+    deleteApmRetentionFilter(param, options) {
+        const requestContextPromise = this.requestFactory.deleteApmRetentionFilter(param.filterId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteApmRetentionFilter(responseContext);
+            });
+        });
+    }
+    /**
+     * Get an APM retention filter.
+     * @param param The request object
+     */
+    getApmRetentionFilter(param, options) {
+        const requestContextPromise = this.requestFactory.getApmRetentionFilter(param.filterId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getApmRetentionFilter(responseContext);
+            });
+        });
+    }
+    /**
+     * Get the list of APM retention filters.
+     * @param param The request object
+     */
+    listApmRetentionFilters(options) {
+        const requestContextPromise = this.requestFactory.listApmRetentionFilters(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listApmRetentionFilters(responseContext);
+            });
+        });
+    }
+    /**
+     * Re-order the execution order of retention filters.
+     * @param param The request object
+     */
+    reorderApmRetentionFilters(param, options) {
+        const requestContextPromise = this.requestFactory.reorderApmRetentionFilters(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.reorderApmRetentionFilters(responseContext);
+            });
+        });
+    }
+    /**
+     * Update a retention filter from your organization.
+     * @param param The request object
+     */
+    updateApmRetentionFilter(param, options) {
+        const requestContextPromise = this.requestFactory.updateApmRetentionFilter(param.filterId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateApmRetentionFilter(responseContext);
+            });
+        });
+    }
+}
+exports.APMRetentionFiltersApi = APMRetentionFiltersApi;
+//# sourceMappingURL=APMRetentionFiltersApi.js.map