@datadog/datadog-api-client 1.47.0 → 1.49.0

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

@@ -31,6 +31,76 @@ const exception_1 = require("../../datadog-api-client-common/exception");
 const SecurityMonitoringSignalListRequest_1 = require("../models/SecurityMonitoringSignalListRequest");
 const SecurityMonitoringSignalListRequestPage_1 = require("../models/SecurityMonitoringSignalListRequestPage");
 class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    attachCase(caseId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'caseId' is not null or undefined
+            if (caseId === null || caseId === undefined) {
+                throw new baseapi_1.RequiredError("caseId", "attachCase");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "attachCase");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/findings/cases/{case_id}".replace("{case_id}", encodeURIComponent(String(caseId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.attachCase")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PATCH);
+            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, "AttachCaseRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
+    attachJiraIssue(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'attachJiraIssue'");
+            if (!_config.unstableOperations["v2.attachJiraIssue"]) {
+                throw new Error("Unstable operation 'attachJiraIssue' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "attachJiraIssue");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/findings/jira_issues";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.attachJiraIssue")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PATCH);
+            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, "AttachJiraIssueRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
     cancelThreatHuntingJob(jobId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -148,6 +218,37 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    createCases(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", "createCases");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/findings/cases";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.createCases")
+                .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, "CreateCaseRequestArray", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
     createCustomFramework(body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -179,6 +280,41 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    createJiraIssues(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createJiraIssues'");
+            if (!_config.unstableOperations["v2.createJiraIssues"]) {
+                throw new Error("Unstable operation 'createJiraIssues' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createJiraIssues");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/findings/jira_issues";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.createJiraIssues")
+                .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, "CreateJiraIssueRequestArray", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
     createSecurityFilter(body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -508,6 +644,37 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    detachCase(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", "detachCase");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/findings/cases";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.detachCase")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            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, "DetachCaseRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
     editSecurityMonitoringSignalAssignee(signalId, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -1069,6 +1236,37 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    getSuppressionVersionHistory(suppressionId, pageSize, pageNumber, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'suppressionId' is not null or undefined
+            if (suppressionId === null || suppressionId === undefined) {
+                throw new baseapi_1.RequiredError("suppressionId", "getSuppressionVersionHistory");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security_monitoring/configuration/suppressions/{suppression_id}/version_history".replace("{suppression_id}", encodeURIComponent(String(suppressionId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getSuppressionVersionHistory")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (pageSize !== undefined) {
+                requestContext.setQueryParam("page[size]", ObjectSerializer_1.ObjectSerializer.serialize(pageSize, "number", "int64"), "");
+            }
+            if (pageNumber !== undefined) {
+                requestContext.setQueryParam("page[number]", ObjectSerializer_1.ObjectSerializer.serialize(pageNumber, "number", "int64"), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
     getThreatHuntingJob(jobId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -1524,7 +1722,7 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
-    listVulnerabilities(pageToken, pageNumber, filterType, filterCvssBaseScoreOp, filterCvssBaseSeverity, filterCvssBaseVector, filterCvssDatadogScoreOp, filterCvssDatadogSeverity, filterCvssDatadogVector, filterStatus, filterTool, filterLibraryName, filterLibraryVersion, filterAdvisoryId, filterRisksExploitationProbability, filterRisksPocExploitAvailable, filterRisksExploitAvailable, filterRisksEpssScoreOp, filterRisksEpssSeverity, filterLanguage, filterEcosystem, filterCodeLocationLocation, filterCodeLocationFilePath, filterCodeLocationMethod, filterFixAvailable, filterRepoDigests, filterOrigin, filterAssetName, filterAssetType, filterAssetVersionFirst, filterAssetVersionLast, filterAssetRepositoryUrl, filterAssetRisksInProduction, filterAssetRisksUnderAttack, filterAssetRisksIsPubliclyAccessible, filterAssetRisksHasPrivilegedAccess, filterAssetRisksHasAccessToSensitiveData, filterAssetEnvironments, filterAssetTeams, filterAssetArch, filterAssetOperatingSystemName, filterAssetOperatingSystemVersion, _options) {
+    listVulnerabilities(pageToken, pageNumber, filterType, filterCvssBaseScoreOp, filterCvssBaseSeverity, filterCvssBaseVector, filterCvssDatadogScoreOp, filterCvssDatadogSeverity, filterCvssDatadogVector, filterStatus, filterTool, filterLibraryName, filterLibraryVersion, filterAdvisoryId, filterRisksExploitationProbability, filterRisksPocExploitAvailable, filterRisksExploitAvailable, filterRisksEpssScoreOp, filterRisksEpssSeverity, filterLanguage, filterEcosystem, filterCodeLocationLocation, filterCodeLocationFilePath, filterCodeLocationMethod, filterFixAvailable, filterRepoDigests, filterOrigin, filterRunningKernel, filterAssetName, filterAssetType, filterAssetVersionFirst, filterAssetVersionLast, filterAssetRepositoryUrl, filterAssetRisksInProduction, filterAssetRisksUnderAttack, filterAssetRisksIsPubliclyAccessible, filterAssetRisksHasPrivilegedAccess, filterAssetRisksHasAccessToSensitiveData, filterAssetEnvironments, filterAssetTeams, filterAssetArch, filterAssetOperatingSystemName, filterAssetOperatingSystemVersion, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
             logger_1.logger.warn("Using unstable operation 'listVulnerabilities'");
@@ -1621,6 +1819,9 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             if (filterOrigin !== undefined) {
                 requestContext.setQueryParam("filter[origin]", ObjectSerializer_1.ObjectSerializer.serialize(filterOrigin, "string", ""), "");
             }
+            if (filterRunningKernel !== undefined) {
+                requestContext.setQueryParam("filter[running_kernel]", ObjectSerializer_1.ObjectSerializer.serialize(filterRunningKernel, "boolean", ""), "");
+            }
             if (filterAssetName !== undefined) {
                 requestContext.setQueryParam("filter[asset.name]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetName, "string", ""), "");
             }
@@ -1779,6 +1980,7 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
                 "apiKeyAuth",
                 "appKeyAuth",
+                "AuthZ",
             ]);
             return requestContext;
         });
@@ -2252,6 +2454,80 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
 }
 exports.SecurityMonitoringApiRequestFactory = SecurityMonitoringApiRequestFactory;
 class SecurityMonitoringApiResponseProcessor {
+    /**
+     * 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 attachCase
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    attachCase(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), "FindingCaseResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                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), "FindingCaseResponse", "");
+                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 attachJiraIssue
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    attachJiraIssue(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), "FindingCaseResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                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), "FindingCaseResponse", "");
+                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
@@ -2404,6 +2680,43 @@ class SecurityMonitoringApiResponseProcessor {
             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 createCases
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createCases(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), "FindingCaseResponseArray");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                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), "FindingCaseResponseArray", "");
+                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
@@ -2442,6 +2755,43 @@ class SecurityMonitoringApiResponseProcessor {
             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 createJiraIssues
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createJiraIssues(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), "FindingCaseResponseArray");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                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), "FindingCaseResponseArray", "");
+                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
@@ -2879,6 +3229,41 @@ class SecurityMonitoringApiResponseProcessor {
             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 detachCase
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    detachCase(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 === 400 ||
+                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
@@ -3594,6 +3979,43 @@ class SecurityMonitoringApiResponseProcessor {
             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 getSuppressionVersionHistory
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getSuppressionVersionHistory(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), "GetSuppressionVersionHistoryResponse");
+                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), "GetSuppressionVersionHistoryResponse", "");
+                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
@@ -4793,6 +5215,36 @@ class SecurityMonitoringApi {
         this.responseProcessor =
             responseProcessor || new SecurityMonitoringApiResponseProcessor();
     }
+    /**
+     * Attach security findings to a case.
+     * You can attach up to 50 security findings per case. Security findings that are already attached to another case will be detached from their previous case and attached to the specified case.
+     * @param param The request object
+     */
+    attachCase(param, options) {
+        const requestContextPromise = this.requestFactory.attachCase(param.caseId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.attachCase(responseContext);
+            });
+        });
+    }
+    /**
+     * Attach security findings to a Jira issue by providing the Jira issue URL.
+     * You can attach up to 50 security findings per Jira issue. If the Jira issue is not linked to any case, this operation will create a case for the security findings and link the Jira issue to the newly created case. To configure the Jira integration, see [Bidirectional ticket syncing with Jira](https://docs.datadoghq.com/security/ticketing_integrations/#bidirectional-ticket-syncing-with-jira). Security findings that are already attached to another Jira issue will be detached from their previous Jira issue and attached to the specified Jira issue.
+     * @param param The request object
+     */
+    attachJiraIssue(param, options) {
+        const requestContextPromise = this.requestFactory.attachJiraIssue(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.attachJiraIssue(responseContext);
+            });
+        });
+    }
     /**
      * Cancel a threat hunting job.
      * @param param The request object
@@ -4808,8 +5260,13 @@ class SecurityMonitoringApi {
         });
     }
     /**
-     * Convert an existing rule from JSON to Terraform for datadog provider
-     * resource datadog_security_monitoring_rule.
+     * Convert an existing rule from JSON to Terraform for Datadog provider
+     * resource `datadog_security_monitoring_rule`. You can do so for the following rule types:
+     * - App and API Protection
+     * - Cloud SIEM (log detection and signal correlation)
+     * - Workload Protection
+     *
+     * You can convert Cloud Security configuration rules using Terraform's [Datadog Cloud Configuration Rule resource](https://registry.terraform.io/providers/DataDog/datadog/latest/docs/resources/cloud_configuration_rule).
      * @param param The request object
      */
     convertExistingSecurityMonitoringRule(param, options) {
@@ -4837,8 +5294,13 @@ class SecurityMonitoringApi {
         });
     }
     /**
-     * Convert a rule that doesn't (yet) exist from JSON to Terraform for datadog provider
-     * resource datadog_security_monitoring_rule.
+     * Convert a rule that doesn't (yet) exist from JSON to Terraform for Datadog provider
+     * resource `datadog_security_monitoring_rule`. You can do so for the following rule types:
+     * - App and API Protection
+     * - Cloud SIEM (log detection and signal correlation)
+     * - Workload Protection
+     *
+     * You can convert Cloud Security configuration rules using Terraform's [Datadog Cloud Configuration Rule resource](https://registry.terraform.io/providers/DataDog/datadog/latest/docs/resources/cloud_configuration_rule).
      * @param param The request object
      */
     convertSecurityMonitoringRuleFromJSONToTerraform(param, options) {
@@ -4851,6 +5313,21 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Create cases for security findings.
+     * You can create up to 50 cases per request and associate up to 50 security findings per case. Security findings that are already attached to another case will be detached from their previous case and attached to the newly created case.
+     * @param param The request object
+     */
+    createCases(param, options) {
+        const requestContextPromise = this.requestFactory.createCases(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createCases(responseContext);
+            });
+        });
+    }
     /**
      * Create a custom framework.
      * @param param The request object
@@ -4865,6 +5342,21 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Create Jira issues for security findings.
+     * This operation creates a case in Datadog and a Jira issue linked to that case for bidirectional sync between Datadog and Jira. To configure the Jira integration, see [Bidirectional ticket syncing with Jira](https://docs.datadoghq.com/security/ticketing_integrations/#bidirectional-ticket-syncing-with-jira). You can create up to 50 Jira issues per request and associate up to 50 security findings per Jira issue. Security findings that are already attached to another Jira issue will be detached from their previous Jira issue and attached to the newly created Jira issue.
+     * @param param The request object
+     */
+    createJiraIssues(param, options) {
+        const requestContextPromise = this.requestFactory.createJiraIssues(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createJiraIssues(responseContext);
+            });
+        });
+    }
     /**
      * Create a security filter.
      *
@@ -5036,6 +5528,21 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Detach security findings from their case.
+     * This operation dissociates security findings from their associated cases without deleting the cases themselves. You can detach security findings from multiple different cases in a single request, with a limit of 50 security findings per request. Security findings that are not currently attached to any case will be ignored.
+     * @param param The request object
+     */
+    detachCase(param, options) {
+        const requestContextPromise = this.requestFactory.detachCase(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.detachCase(responseContext);
+            });
+        });
+    }
     /**
      * Modify the triage assignee of a security signal.
      * @param param The request object
@@ -5149,7 +5656,7 @@ class SecurityMonitoringApi {
         });
     }
     /**
-     * Returns list of Secrets rules with ID, Pattern, Description, Priority, and SDS ID
+     * Returns a list of Secrets rules with ID, Pattern, Description, Priority, and SDS ID.
      * @param param The request object
      */
     getSecretsRules(options) {
@@ -5305,6 +5812,20 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Get a suppression's version history.
+     * @param param The request object
+     */
+    getSuppressionVersionHistory(param, options) {
+        const requestContextPromise = this.requestFactory.getSuppressionVersionHistory(param.suppressionId, param.pageSize, param.pageNumber, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getSuppressionVersionHistory(responseContext);
+            });
+        });
+    }
     /**
      * Get a job's details.
      * @param param The request object
@@ -5762,7 +6283,7 @@ class SecurityMonitoringApi {
      * @param param The request object
      */
     listVulnerabilities(param = {}, options) {
-        const requestContextPromise = this.requestFactory.listVulnerabilities(param.pageToken, param.pageNumber, param.filterType, param.filterCvssBaseScoreOp, param.filterCvssBaseSeverity, param.filterCvssBaseVector, param.filterCvssDatadogScoreOp, param.filterCvssDatadogSeverity, param.filterCvssDatadogVector, param.filterStatus, param.filterTool, param.filterLibraryName, param.filterLibraryVersion, param.filterAdvisoryId, param.filterRisksExploitationProbability, param.filterRisksPocExploitAvailable, param.filterRisksExploitAvailable, param.filterRisksEpssScoreOp, param.filterRisksEpssSeverity, param.filterLanguage, param.filterEcosystem, param.filterCodeLocationLocation, param.filterCodeLocationFilePath, param.filterCodeLocationMethod, param.filterFixAvailable, param.filterRepoDigests, param.filterOrigin, param.filterAssetName, param.filterAssetType, param.filterAssetVersionFirst, param.filterAssetVersionLast, param.filterAssetRepositoryUrl, param.filterAssetRisksInProduction, param.filterAssetRisksUnderAttack, param.filterAssetRisksIsPubliclyAccessible, param.filterAssetRisksHasPrivilegedAccess, param.filterAssetRisksHasAccessToSensitiveData, param.filterAssetEnvironments, param.filterAssetTeams, param.filterAssetArch, param.filterAssetOperatingSystemName, param.filterAssetOperatingSystemVersion, options);
+        const requestContextPromise = this.requestFactory.listVulnerabilities(param.pageToken, param.pageNumber, param.filterType, param.filterCvssBaseScoreOp, param.filterCvssBaseSeverity, param.filterCvssBaseVector, param.filterCvssDatadogScoreOp, param.filterCvssDatadogSeverity, param.filterCvssDatadogVector, param.filterStatus, param.filterTool, param.filterLibraryName, param.filterLibraryVersion, param.filterAdvisoryId, param.filterRisksExploitationProbability, param.filterRisksPocExploitAvailable, param.filterRisksExploitAvailable, param.filterRisksEpssScoreOp, param.filterRisksEpssSeverity, param.filterLanguage, param.filterEcosystem, param.filterCodeLocationLocation, param.filterCodeLocationFilePath, param.filterCodeLocationMethod, param.filterFixAvailable, param.filterRepoDigests, param.filterOrigin, param.filterRunningKernel, param.filterAssetName, param.filterAssetType, param.filterAssetVersionFirst, param.filterAssetVersionLast, param.filterAssetRepositoryUrl, param.filterAssetRisksInProduction, param.filterAssetRisksUnderAttack, param.filterAssetRisksIsPubliclyAccessible, param.filterAssetRisksHasPrivilegedAccess, param.filterAssetRisksHasAccessToSensitiveData, param.filterAssetEnvironments, param.filterAssetTeams, param.filterAssetArch, param.filterAssetOperatingSystemName, param.filterAssetOperatingSystemVersion, options);
         return requestContextPromise.then((requestContext) => {
             return this.configuration.httpApi
                 .send(requestContext)