@datadog/datadog-api-client 1.52.0 → 1.56.0

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

@@ -0,0 +1,1557 @@
+"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.FeatureFlagsApi = exports.FeatureFlagsApiResponseProcessor = exports.FeatureFlagsApiRequestFactory = 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 FeatureFlagsApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    archiveFeatureFlag(featureFlagId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "archiveFeatureFlag");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}/archive".replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.archiveFeatureFlag")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createAllocationsForFeatureFlagInEnvironment(featureFlagId, environmentId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "createAllocationsForFeatureFlagInEnvironment");
+            }
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "createAllocationsForFeatureFlagInEnvironment");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createAllocationsForFeatureFlagInEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/allocations"
+                .replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)))
+                .replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.createAllocationsForFeatureFlagInEnvironment")
+                .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, "CreateAllocationsRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createFeatureFlag(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", "createFeatureFlag");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.createFeatureFlag")
+                .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, "CreateFeatureFlagRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createFeatureFlagsEnvironment(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", "createFeatureFlagsEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/environments";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.createFeatureFlagsEnvironment")
+                .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, "CreateEnvironmentRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    deleteFeatureFlagsEnvironment(environmentId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "deleteFeatureFlagsEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/environments/{environment_id}".replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.deleteFeatureFlagsEnvironment")
+                .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;
+        });
+    }
+    disableFeatureFlagEnvironment(featureFlagId, environmentId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "disableFeatureFlagEnvironment");
+            }
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "disableFeatureFlagEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/disable"
+                .replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)))
+                .replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.disableFeatureFlagEnvironment")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    enableFeatureFlagEnvironment(featureFlagId, environmentId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "enableFeatureFlagEnvironment");
+            }
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "enableFeatureFlagEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/enable"
+                .replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)))
+                .replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.enableFeatureFlagEnvironment")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getFeatureFlag(featureFlagId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "getFeatureFlag");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}".replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.getFeatureFlag")
+                .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;
+        });
+    }
+    getFeatureFlagsEnvironment(environmentId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "getFeatureFlagsEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/environments/{environment_id}".replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.getFeatureFlagsEnvironment")
+                .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;
+        });
+    }
+    listFeatureFlags(key, isArchived, limit, offset, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.listFeatureFlags")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (key !== undefined) {
+                requestContext.setQueryParam("key", ObjectSerializer_1.ObjectSerializer.serialize(key, "string", ""), "");
+            }
+            if (isArchived !== undefined) {
+                requestContext.setQueryParam("is_archived", ObjectSerializer_1.ObjectSerializer.serialize(isArchived, "boolean", ""), "");
+            }
+            if (limit !== undefined) {
+                requestContext.setQueryParam("limit", ObjectSerializer_1.ObjectSerializer.serialize(limit, "number", ""), "");
+            }
+            if (offset !== undefined) {
+                requestContext.setQueryParam("offset", ObjectSerializer_1.ObjectSerializer.serialize(offset, "number", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listFeatureFlagsEnvironments(name, key, limit, offset, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/environments";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.listFeatureFlagsEnvironments")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (name !== undefined) {
+                requestContext.setQueryParam("name", ObjectSerializer_1.ObjectSerializer.serialize(name, "string", ""), "");
+            }
+            if (key !== undefined) {
+                requestContext.setQueryParam("key", ObjectSerializer_1.ObjectSerializer.serialize(key, "string", ""), "");
+            }
+            if (limit !== undefined) {
+                requestContext.setQueryParam("limit", ObjectSerializer_1.ObjectSerializer.serialize(limit, "number", ""), "");
+            }
+            if (offset !== undefined) {
+                requestContext.setQueryParam("offset", ObjectSerializer_1.ObjectSerializer.serialize(offset, "number", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    pauseExposureSchedule(exposureScheduleId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'exposureScheduleId' is not null or undefined
+            if (exposureScheduleId === null || exposureScheduleId === undefined) {
+                throw new baseapi_1.RequiredError("exposureScheduleId", "pauseExposureSchedule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/pause".replace("{exposure_schedule_id}", encodeURIComponent(String(exposureScheduleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.pauseExposureSchedule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    resumeExposureSchedule(exposureScheduleId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'exposureScheduleId' is not null or undefined
+            if (exposureScheduleId === null || exposureScheduleId === undefined) {
+                throw new baseapi_1.RequiredError("exposureScheduleId", "resumeExposureSchedule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/resume".replace("{exposure_schedule_id}", encodeURIComponent(String(exposureScheduleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.resumeExposureSchedule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    startExposureSchedule(exposureScheduleId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'exposureScheduleId' is not null or undefined
+            if (exposureScheduleId === null || exposureScheduleId === undefined) {
+                throw new baseapi_1.RequiredError("exposureScheduleId", "startExposureSchedule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/start".replace("{exposure_schedule_id}", encodeURIComponent(String(exposureScheduleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.startExposureSchedule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    stopExposureSchedule(exposureScheduleId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'exposureScheduleId' is not null or undefined
+            if (exposureScheduleId === null || exposureScheduleId === undefined) {
+                throw new baseapi_1.RequiredError("exposureScheduleId", "stopExposureSchedule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/stop".replace("{exposure_schedule_id}", encodeURIComponent(String(exposureScheduleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.stopExposureSchedule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    unarchiveFeatureFlag(featureFlagId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "unarchiveFeatureFlag");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}/unarchive".replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.unarchiveFeatureFlag")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateAllocationsForFeatureFlagInEnvironment(featureFlagId, environmentId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "updateAllocationsForFeatureFlagInEnvironment");
+            }
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "updateAllocationsForFeatureFlagInEnvironment");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateAllocationsForFeatureFlagInEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/allocations"
+                .replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)))
+                .replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.updateAllocationsForFeatureFlagInEnvironment")
+                .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, "OverwriteAllocationsRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateFeatureFlag(featureFlagId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'featureFlagId' is not null or undefined
+            if (featureFlagId === null || featureFlagId === undefined) {
+                throw new baseapi_1.RequiredError("featureFlagId", "updateFeatureFlag");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateFeatureFlag");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/{feature_flag_id}".replace("{feature_flag_id}", encodeURIComponent(String(featureFlagId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.updateFeatureFlag")
+                .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, "UpdateFeatureFlagRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateFeatureFlagsEnvironment(environmentId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'environmentId' is not null or undefined
+            if (environmentId === null || environmentId === undefined) {
+                throw new baseapi_1.RequiredError("environmentId", "updateFeatureFlagsEnvironment");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateFeatureFlagsEnvironment");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/feature-flags/environments/{environment_id}".replace("{environment_id}", encodeURIComponent(String(environmentId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.FeatureFlagsApi.updateFeatureFlagsEnvironment")
+                .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, "UpdateEnvironmentRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+}
+exports.FeatureFlagsApiRequestFactory = FeatureFlagsApiRequestFactory;
+class FeatureFlagsApiResponseProcessor {
+    /**
+     * 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 archiveFeatureFlag
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    archiveFeatureFlag(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), "FeatureFlagResponse");
+                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.debug(`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), "FeatureFlagResponse", "");
+                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 createAllocationsForFeatureFlagInEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createAllocationsForFeatureFlagInEnvironment(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 201 || response.httpStatusCode === 202) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AllocationResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                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.debug(`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), "AllocationResponse", "");
+                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 createFeatureFlag
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createFeatureFlag(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 201) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "FeatureFlagResponse");
+                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.debug(`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), "FeatureFlagResponse", "");
+                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 createFeatureFlagsEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createFeatureFlagsEnvironment(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 201) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "EnvironmentResponse");
+                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.debug(`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), "EnvironmentResponse", "");
+                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 deleteFeatureFlagsEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteFeatureFlagsEnvironment(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 204) {
+                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.debug(`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) {
+                return;
+            }
+            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 disableFeatureFlagEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    disableFeatureFlagEnvironment(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200 || response.httpStatusCode === 202) {
+                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.debug(`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) {
+                return;
+            }
+            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 enableFeatureFlagEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    enableFeatureFlagEnvironment(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200 || response.httpStatusCode === 202) {
+                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.debug(`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) {
+                return;
+            }
+            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 getFeatureFlag
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getFeatureFlag(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), "FeatureFlagResponse");
+                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.debug(`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), "FeatureFlagResponse", "");
+                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 getFeatureFlagsEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getFeatureFlagsEnvironment(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), "EnvironmentResponse");
+                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.debug(`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), "EnvironmentResponse", "");
+                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 listFeatureFlags
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listFeatureFlags(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), "ListFeatureFlagsResponse");
+                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.debug(`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), "ListFeatureFlagsResponse", "");
+                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 listFeatureFlagsEnvironments
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listFeatureFlagsEnvironments(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), "ListEnvironmentsResponse");
+                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.debug(`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), "ListEnvironmentsResponse", "");
+                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 pauseExposureSchedule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    pauseExposureSchedule(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), "AllocationExposureScheduleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                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.debug(`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), "AllocationExposureScheduleResponse", "");
+                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 resumeExposureSchedule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    resumeExposureSchedule(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), "AllocationExposureScheduleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                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.debug(`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), "AllocationExposureScheduleResponse", "");
+                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 startExposureSchedule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    startExposureSchedule(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), "AllocationExposureScheduleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                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.debug(`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), "AllocationExposureScheduleResponse", "");
+                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 stopExposureSchedule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    stopExposureSchedule(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), "AllocationExposureScheduleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                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.debug(`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), "AllocationExposureScheduleResponse", "");
+                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 unarchiveFeatureFlag
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    unarchiveFeatureFlag(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), "FeatureFlagResponse");
+                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.debug(`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), "FeatureFlagResponse", "");
+                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 updateAllocationsForFeatureFlagInEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateAllocationsForFeatureFlagInEnvironment(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200 || response.httpStatusCode === 202) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListAllocationsResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                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.debug(`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), "ListAllocationsResponse", "");
+                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 updateFeatureFlag
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateFeatureFlag(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), "FeatureFlagResponse");
+                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.debug(`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), "FeatureFlagResponse", "");
+                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 updateFeatureFlagsEnvironment
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    updateFeatureFlagsEnvironment(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), "EnvironmentResponse");
+                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.debug(`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), "EnvironmentResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+}
+exports.FeatureFlagsApiResponseProcessor = FeatureFlagsApiResponseProcessor;
+class FeatureFlagsApi {
+    constructor(configuration, requestFactory, responseProcessor) {
+        this.configuration = configuration;
+        this.requestFactory =
+            requestFactory || new FeatureFlagsApiRequestFactory(configuration);
+        this.responseProcessor =
+            responseProcessor || new FeatureFlagsApiResponseProcessor();
+    }
+    /**
+     * Archives a feature flag. Archived flags are
+     * hidden from the main list but remain accessible and can be unarchived.
+     * @param param The request object
+     */
+    archiveFeatureFlag(param, options) {
+        const requestContextPromise = this.requestFactory.archiveFeatureFlag(param.featureFlagId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.archiveFeatureFlag(responseContext);
+            });
+        });
+    }
+    /**
+     * Creates a new targeting rule (allocation) for a specific feature flag in a specific environment.
+     * @param param The request object
+     */
+    createAllocationsForFeatureFlagInEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.createAllocationsForFeatureFlagInEnvironment(param.featureFlagId, param.environmentId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createAllocationsForFeatureFlagInEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Creates a new feature flag with variants.
+     * @param param The request object
+     */
+    createFeatureFlag(param, options) {
+        const requestContextPromise = this.requestFactory.createFeatureFlag(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createFeatureFlag(responseContext);
+            });
+        });
+    }
+    /**
+     * Creates a new environment for organizing feature flags.
+     * @param param The request object
+     */
+    createFeatureFlagsEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.createFeatureFlagsEnvironment(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createFeatureFlagsEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Deletes an environment. This operation cannot be undone.
+     * @param param The request object
+     */
+    deleteFeatureFlagsEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.deleteFeatureFlagsEnvironment(param.environmentId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteFeatureFlagsEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Disable a feature flag in a specific environment.
+     * @param param The request object
+     */
+    disableFeatureFlagEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.disableFeatureFlagEnvironment(param.featureFlagId, param.environmentId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.disableFeatureFlagEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Enable a feature flag in a specific environment.
+     * @param param The request object
+     */
+    enableFeatureFlagEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.enableFeatureFlagEnvironment(param.featureFlagId, param.environmentId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.enableFeatureFlagEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Returns the details of a specific feature flag
+     * including variants and environment status.
+     * @param param The request object
+     */
+    getFeatureFlag(param, options) {
+        const requestContextPromise = this.requestFactory.getFeatureFlag(param.featureFlagId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getFeatureFlag(responseContext);
+            });
+        });
+    }
+    /**
+     * Returns the details of a specific environment.
+     * @param param The request object
+     */
+    getFeatureFlagsEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.getFeatureFlagsEnvironment(param.environmentId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getFeatureFlagsEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Returns a list of feature flags for the organization.
+     * Supports filtering by key and archived status.
+     * @param param The request object
+     */
+    listFeatureFlags(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listFeatureFlags(param.key, param.isArchived, param.limit, param.offset, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listFeatureFlags(responseContext);
+            });
+        });
+    }
+    /**
+     * Returns a list of environments for the organization.
+     * Supports filtering by name and key.
+     * @param param The request object
+     */
+    listFeatureFlagsEnvironments(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listFeatureFlagsEnvironments(param.name, param.key, param.limit, param.offset, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listFeatureFlagsEnvironments(responseContext);
+            });
+        });
+    }
+    /**
+     * Pauses a progressive rollout while preserving rollout state.
+     * @param param The request object
+     */
+    pauseExposureSchedule(param, options) {
+        const requestContextPromise = this.requestFactory.pauseExposureSchedule(param.exposureScheduleId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.pauseExposureSchedule(responseContext);
+            });
+        });
+    }
+    /**
+     * Resumes progression for a previously paused progressive rollout.
+     * @param param The request object
+     */
+    resumeExposureSchedule(param, options) {
+        const requestContextPromise = this.requestFactory.resumeExposureSchedule(param.exposureScheduleId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.resumeExposureSchedule(responseContext);
+            });
+        });
+    }
+    /**
+     * Starts a progressive rollout and begins progression.
+     * @param param The request object
+     */
+    startExposureSchedule(param, options) {
+        const requestContextPromise = this.requestFactory.startExposureSchedule(param.exposureScheduleId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.startExposureSchedule(responseContext);
+            });
+        });
+    }
+    /**
+     * Stops a progressive rollout and marks it as aborted.
+     * @param param The request object
+     */
+    stopExposureSchedule(param, options) {
+        const requestContextPromise = this.requestFactory.stopExposureSchedule(param.exposureScheduleId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.stopExposureSchedule(responseContext);
+            });
+        });
+    }
+    /**
+     * Unarchives a previously archived feature flag,
+     * making it visible in the main list again.
+     * @param param The request object
+     */
+    unarchiveFeatureFlag(param, options) {
+        const requestContextPromise = this.requestFactory.unarchiveFeatureFlag(param.featureFlagId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.unarchiveFeatureFlag(responseContext);
+            });
+        });
+    }
+    /**
+     * Updates targeting rules (allocations) for a specific feature flag in a specific environment.
+     * This operation replaces the existing allocation set with the request payload.
+     * @param param The request object
+     */
+    updateAllocationsForFeatureFlagInEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.updateAllocationsForFeatureFlagInEnvironment(param.featureFlagId, param.environmentId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateAllocationsForFeatureFlagInEnvironment(responseContext);
+            });
+        });
+    }
+    /**
+     * Updates an existing feature flag's metadata such as
+     *  name and description. Does not modify targeting rules or allocations.
+     * @param param The request object
+     */
+    updateFeatureFlag(param, options) {
+        const requestContextPromise = this.requestFactory.updateFeatureFlag(param.featureFlagId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateFeatureFlag(responseContext);
+            });
+        });
+    }
+    /**
+     * Updates an existing environment's metadata such as
+     *  name and description.
+     * @param param The request object
+     */
+    updateFeatureFlagsEnvironment(param, options) {
+        const requestContextPromise = this.requestFactory.updateFeatureFlagsEnvironment(param.environmentId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateFeatureFlagsEnvironment(responseContext);
+            });
+        });
+    }
+}
+exports.FeatureFlagsApi = FeatureFlagsApi;
+//# sourceMappingURL=FeatureFlagsApi.js.map