@datadog/datadog-api-client 1.31.0 → 1.33.0

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

@@ -241,6 +241,68 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    createSignalNotificationRule(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", "createSignalNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/signals/notification_rules";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.createSignalNotificationRule")
+                .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, "CreateNotificationRuleParameters", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createVulnerabilityNotificationRule(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", "createVulnerabilityNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/vulnerabilities/notification_rules";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.createVulnerabilityNotificationRule")
+                .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, "CreateNotificationRuleParameters", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     deleteHistoricalJob(jobId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -341,6 +403,54 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    deleteSignalNotificationRule(id, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "deleteSignalNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/signals/notification_rules/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.deleteSignalNotificationRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    deleteVulnerabilityNotificationRule(id, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "deleteVulnerabilityNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/vulnerabilities/notification_rules/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.deleteVulnerabilityNotificationRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     editSecurityMonitoringSignalAssignee(signalId, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -503,6 +613,80 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    getRuleVersionHistory(ruleId, pageSize, pageNumber, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getRuleVersionHistory'");
+            if (!_config.unstableOperations["v2.getRuleVersionHistory"]) {
+                throw new Error("Unstable operation 'getRuleVersionHistory' is disabled");
+            }
+            // verify required parameter 'ruleId' is not null or undefined
+            if (ruleId === null || ruleId === undefined) {
+                throw new baseapi_1.RequiredError("ruleId", "getRuleVersionHistory");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security_monitoring/rules/{rule_id}/version_history".replace("{rule_id}", encodeURIComponent(String(ruleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getRuleVersionHistory")
+                .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, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getSBOM(assetType, filterAssetName, filterRepoDigest, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getSBOM'");
+            if (!_config.unstableOperations["v2.getSBOM"]) {
+                throw new Error("Unstable operation 'getSBOM' is disabled");
+            }
+            // verify required parameter 'assetType' is not null or undefined
+            if (assetType === null || assetType === undefined) {
+                throw new baseapi_1.RequiredError("assetType", "getSBOM");
+            }
+            // verify required parameter 'filterAssetName' is not null or undefined
+            if (filterAssetName === null || filterAssetName === undefined) {
+                throw new baseapi_1.RequiredError("filterAssetName", "getSBOM");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/sboms/{asset_type}".replace("{asset_type}", encodeURIComponent(String(assetType)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getSBOM")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (filterAssetName !== undefined) {
+                requestContext.setQueryParam("filter[asset_name]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetName, "string", ""), "");
+            }
+            if (filterRepoDigest !== undefined) {
+                requestContext.setQueryParam("filter[repo_digest]", ObjectSerializer_1.ObjectSerializer.serialize(filterRepoDigest, "string", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     getSecurityFilter(securityFilterId, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -599,6 +783,94 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    getSignalNotificationRule(id, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "getSignalNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/signals/notification_rules/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getSignalNotificationRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getSignalNotificationRules(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // Path Params
+            const localVarPath = "/api/v2/security/signals/notification_rules";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getSignalNotificationRules")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getVulnerabilityNotificationRule(id, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "getVulnerabilityNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/vulnerabilities/notification_rules/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getVulnerabilityNotificationRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getVulnerabilityNotificationRules(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // Path Params
+            const localVarPath = "/api/v2/security/vulnerabilities/notification_rules";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.getVulnerabilityNotificationRules")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     listFindings(pageLimit, snapshotTimestamp, pageCursor, filterTags, filterEvaluationChangedAt, filterMuted, filterRuleId, filterRuleName, filterResourceType, filterDiscoveryTimestamp, filterEvaluation, filterStatus, filterVulnerabilityType, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -806,59 +1078,347 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
-    muteFindings(body, _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, filterAssetName, filterAssetType, filterAssetVersionFirst, filterAssetVersionLast, filterAssetRepositoryUrl, filterAssetRisksInProduction, filterAssetRisksUnderAttack, filterAssetRisksIsPubliclyAccessible, filterAssetRisksHasPrivilegedAccess, filterAssetRisksHasAccessToSensitiveData, filterAssetEnvironments, filterAssetArch, filterAssetOperatingSystemName, filterAssetOperatingSystemVersion, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'muteFindings'");
-            if (!_config.unstableOperations["v2.muteFindings"]) {
-                throw new Error("Unstable operation 'muteFindings' is disabled");
-            }
-            // verify required parameter 'body' is not null or undefined
-            if (body === null || body === undefined) {
-                throw new baseapi_1.RequiredError("body", "muteFindings");
+            logger_1.logger.warn("Using unstable operation 'listVulnerabilities'");
+            if (!_config.unstableOperations["v2.listVulnerabilities"]) {
+                throw new Error("Unstable operation 'listVulnerabilities' is disabled");
             }
             // Path Params
-            const localVarPath = "/api/v2/posture_management/findings";
+            const localVarPath = "/api/v2/security/vulnerabilities";
             // Make Request Context
             const requestContext = _config
-                .getServer("v2.SecurityMonitoringApi.muteFindings")
-                .makeRequestContext(localVarPath, http_1.HttpMethod.PATCH);
+                .getServer("v2.SecurityMonitoringApi.listVulnerabilities")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
             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, "BulkMuteFindingsRequest", ""), contentType);
-            requestContext.setBody(serializedBody);
-            // Apply auth methods
-            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
-                "apiKeyAuth",
-                "appKeyAuth",
-            ]);
-            return requestContext;
-        });
-    }
-    runHistoricalJob(body, _options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'runHistoricalJob'");
-            if (!_config.unstableOperations["v2.runHistoricalJob"]) {
-                throw new Error("Unstable operation 'runHistoricalJob' is disabled");
+            // Query Params
+            if (pageToken !== undefined) {
+                requestContext.setQueryParam("page[token]", ObjectSerializer_1.ObjectSerializer.serialize(pageToken, "string", ""), "");
             }
-            // verify required parameter 'body' is not null or undefined
-            if (body === null || body === undefined) {
-                throw new baseapi_1.RequiredError("body", "runHistoricalJob");
+            if (pageNumber !== undefined) {
+                requestContext.setQueryParam("page[number]", ObjectSerializer_1.ObjectSerializer.serialize(pageNumber, "number", "int64"), "");
             }
-            // Path Params
-            const localVarPath = "/api/v2/siem-historical-detections/jobs";
-            // Make Request Context
-            const requestContext = _config
-                .getServer("v2.SecurityMonitoringApi.runHistoricalJob")
-                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
-            requestContext.setHeaderParam("Accept", "application/json");
-            requestContext.setHttpConfig(_config.httpConfig);
+            if (filterType !== undefined) {
+                requestContext.setQueryParam("filter[type]", ObjectSerializer_1.ObjectSerializer.serialize(filterType, "VulnerabilityType", ""), "");
+            }
+            if (filterCvssBaseScoreOp !== undefined) {
+                requestContext.setQueryParam("filter[cvss.base.score][`$op`]", ObjectSerializer_1.ObjectSerializer.serialize(filterCvssBaseScoreOp, "number", "double"), "");
+            }
+            if (filterCvssBaseSeverity !== undefined) {
+                requestContext.setQueryParam("filter[cvss.base.severity]", ObjectSerializer_1.ObjectSerializer.serialize(filterCvssBaseSeverity, "VulnerabilitySeverity", ""), "");
+            }
+            if (filterCvssBaseVector !== undefined) {
+                requestContext.setQueryParam("filter[cvss.base.vector]", ObjectSerializer_1.ObjectSerializer.serialize(filterCvssBaseVector, "string", ""), "");
+            }
+            if (filterCvssDatadogScoreOp !== undefined) {
+                requestContext.setQueryParam("filter[cvss.datadog.score][`$op`]", ObjectSerializer_1.ObjectSerializer.serialize(filterCvssDatadogScoreOp, "number", "double"), "");
+            }
+            if (filterCvssDatadogSeverity !== undefined) {
+                requestContext.setQueryParam("filter[cvss.datadog.severity]", ObjectSerializer_1.ObjectSerializer.serialize(filterCvssDatadogSeverity, "VulnerabilitySeverity", ""), "");
+            }
+            if (filterCvssDatadogVector !== undefined) {
+                requestContext.setQueryParam("filter[cvss.datadog.vector]", ObjectSerializer_1.ObjectSerializer.serialize(filterCvssDatadogVector, "string", ""), "");
+            }
+            if (filterStatus !== undefined) {
+                requestContext.setQueryParam("filter[status]", ObjectSerializer_1.ObjectSerializer.serialize(filterStatus, "VulnerabilityStatus", ""), "");
+            }
+            if (filterTool !== undefined) {
+                requestContext.setQueryParam("filter[tool]", ObjectSerializer_1.ObjectSerializer.serialize(filterTool, "VulnerabilityTool", ""), "");
+            }
+            if (filterLibraryName !== undefined) {
+                requestContext.setQueryParam("filter[library.name]", ObjectSerializer_1.ObjectSerializer.serialize(filterLibraryName, "string", ""), "");
+            }
+            if (filterLibraryVersion !== undefined) {
+                requestContext.setQueryParam("filter[library.version]", ObjectSerializer_1.ObjectSerializer.serialize(filterLibraryVersion, "string", ""), "");
+            }
+            if (filterAdvisoryId !== undefined) {
+                requestContext.setQueryParam("filter[advisory_id]", ObjectSerializer_1.ObjectSerializer.serialize(filterAdvisoryId, "string", ""), "");
+            }
+            if (filterRisksExploitationProbability !== undefined) {
+                requestContext.setQueryParam("filter[risks.exploitation_probability]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksExploitationProbability, "boolean", ""), "");
+            }
+            if (filterRisksPocExploitAvailable !== undefined) {
+                requestContext.setQueryParam("filter[risks.poc_exploit_available]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksPocExploitAvailable, "boolean", ""), "");
+            }
+            if (filterRisksExploitAvailable !== undefined) {
+                requestContext.setQueryParam("filter[risks.exploit_available]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksExploitAvailable, "boolean", ""), "");
+            }
+            if (filterRisksEpssScoreOp !== undefined) {
+                requestContext.setQueryParam("filter[risks.epss.score][`$op`]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksEpssScoreOp, "number", "double"), "");
+            }
+            if (filterRisksEpssSeverity !== undefined) {
+                requestContext.setQueryParam("filter[risks.epss.severity]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksEpssSeverity, "VulnerabilitySeverity", ""), "");
+            }
+            if (filterLanguage !== undefined) {
+                requestContext.setQueryParam("filter[language]", ObjectSerializer_1.ObjectSerializer.serialize(filterLanguage, "string", ""), "");
+            }
+            if (filterEcosystem !== undefined) {
+                requestContext.setQueryParam("filter[ecosystem]", ObjectSerializer_1.ObjectSerializer.serialize(filterEcosystem, "VulnerabilityEcosystem", ""), "");
+            }
+            if (filterCodeLocationLocation !== undefined) {
+                requestContext.setQueryParam("filter[code_location.location]", ObjectSerializer_1.ObjectSerializer.serialize(filterCodeLocationLocation, "string", ""), "");
+            }
+            if (filterCodeLocationFilePath !== undefined) {
+                requestContext.setQueryParam("filter[code_location.file_path]", ObjectSerializer_1.ObjectSerializer.serialize(filterCodeLocationFilePath, "string", ""), "");
+            }
+            if (filterCodeLocationMethod !== undefined) {
+                requestContext.setQueryParam("filter[code_location.method]", ObjectSerializer_1.ObjectSerializer.serialize(filterCodeLocationMethod, "string", ""), "");
+            }
+            if (filterFixAvailable !== undefined) {
+                requestContext.setQueryParam("filter[fix_available]", ObjectSerializer_1.ObjectSerializer.serialize(filterFixAvailable, "boolean", ""), "");
+            }
+            if (filterRepoDigests !== undefined) {
+                requestContext.setQueryParam("filter[repo_digests]", ObjectSerializer_1.ObjectSerializer.serialize(filterRepoDigests, "string", ""), "");
+            }
+            if (filterAssetName !== undefined) {
+                requestContext.setQueryParam("filter[asset.name]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetName, "string", ""), "");
+            }
+            if (filterAssetType !== undefined) {
+                requestContext.setQueryParam("filter[asset.type]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetType, "AssetType", ""), "");
+            }
+            if (filterAssetVersionFirst !== undefined) {
+                requestContext.setQueryParam("filter[asset.version.first]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetVersionFirst, "string", ""), "");
+            }
+            if (filterAssetVersionLast !== undefined) {
+                requestContext.setQueryParam("filter[asset.version.last]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetVersionLast, "string", ""), "");
+            }
+            if (filterAssetRepositoryUrl !== undefined) {
+                requestContext.setQueryParam("filter[asset.repository_url]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetRepositoryUrl, "string", ""), "");
+            }
+            if (filterAssetRisksInProduction !== undefined) {
+                requestContext.setQueryParam("filter[asset.risks.in_production]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetRisksInProduction, "boolean", ""), "");
+            }
+            if (filterAssetRisksUnderAttack !== undefined) {
+                requestContext.setQueryParam("filter[asset.risks.under_attack]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetRisksUnderAttack, "boolean", ""), "");
+            }
+            if (filterAssetRisksIsPubliclyAccessible !== undefined) {
+                requestContext.setQueryParam("filter[asset.risks.is_publicly_accessible]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetRisksIsPubliclyAccessible, "boolean", ""), "");
+            }
+            if (filterAssetRisksHasPrivilegedAccess !== undefined) {
+                requestContext.setQueryParam("filter[asset.risks.has_privileged_access]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetRisksHasPrivilegedAccess, "boolean", ""), "");
+            }
+            if (filterAssetRisksHasAccessToSensitiveData !== undefined) {
+                requestContext.setQueryParam("filter[asset.risks.has_access_to_sensitive_data]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetRisksHasAccessToSensitiveData, "boolean", ""), "");
+            }
+            if (filterAssetEnvironments !== undefined) {
+                requestContext.setQueryParam("filter[asset.environments]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetEnvironments, "string", ""), "");
+            }
+            if (filterAssetArch !== undefined) {
+                requestContext.setQueryParam("filter[asset.arch]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetArch, "string", ""), "");
+            }
+            if (filterAssetOperatingSystemName !== undefined) {
+                requestContext.setQueryParam("filter[asset.operating_system.name]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetOperatingSystemName, "string", ""), "");
+            }
+            if (filterAssetOperatingSystemVersion !== undefined) {
+                requestContext.setQueryParam("filter[asset.operating_system.version]", ObjectSerializer_1.ObjectSerializer.serialize(filterAssetOperatingSystemVersion, "string", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listVulnerableAssets(pageToken, pageNumber, filterName, filterType, filterVersionFirst, filterVersionLast, filterRepositoryUrl, filterRisksInProduction, filterRisksUnderAttack, filterRisksIsPubliclyAccessible, filterRisksHasPrivilegedAccess, filterRisksHasAccessToSensitiveData, filterEnvironments, filterArch, filterOperatingSystemName, filterOperatingSystemVersion, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listVulnerableAssets'");
+            if (!_config.unstableOperations["v2.listVulnerableAssets"]) {
+                throw new Error("Unstable operation 'listVulnerableAssets' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/assets";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.listVulnerableAssets")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (pageToken !== undefined) {
+                requestContext.setQueryParam("page[token]", ObjectSerializer_1.ObjectSerializer.serialize(pageToken, "string", ""), "");
+            }
+            if (pageNumber !== undefined) {
+                requestContext.setQueryParam("page[number]", ObjectSerializer_1.ObjectSerializer.serialize(pageNumber, "number", "int64"), "");
+            }
+            if (filterName !== undefined) {
+                requestContext.setQueryParam("filter[name]", ObjectSerializer_1.ObjectSerializer.serialize(filterName, "string", ""), "");
+            }
+            if (filterType !== undefined) {
+                requestContext.setQueryParam("filter[type]", ObjectSerializer_1.ObjectSerializer.serialize(filterType, "AssetType", ""), "");
+            }
+            if (filterVersionFirst !== undefined) {
+                requestContext.setQueryParam("filter[version.first]", ObjectSerializer_1.ObjectSerializer.serialize(filterVersionFirst, "string", ""), "");
+            }
+            if (filterVersionLast !== undefined) {
+                requestContext.setQueryParam("filter[version.last]", ObjectSerializer_1.ObjectSerializer.serialize(filterVersionLast, "string", ""), "");
+            }
+            if (filterRepositoryUrl !== undefined) {
+                requestContext.setQueryParam("filter[repository_url]", ObjectSerializer_1.ObjectSerializer.serialize(filterRepositoryUrl, "string", ""), "");
+            }
+            if (filterRisksInProduction !== undefined) {
+                requestContext.setQueryParam("filter[risks.in_production]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksInProduction, "boolean", ""), "");
+            }
+            if (filterRisksUnderAttack !== undefined) {
+                requestContext.setQueryParam("filter[risks.under_attack]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksUnderAttack, "boolean", ""), "");
+            }
+            if (filterRisksIsPubliclyAccessible !== undefined) {
+                requestContext.setQueryParam("filter[risks.is_publicly_accessible]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksIsPubliclyAccessible, "boolean", ""), "");
+            }
+            if (filterRisksHasPrivilegedAccess !== undefined) {
+                requestContext.setQueryParam("filter[risks.has_privileged_access]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksHasPrivilegedAccess, "boolean", ""), "");
+            }
+            if (filterRisksHasAccessToSensitiveData !== undefined) {
+                requestContext.setQueryParam("filter[risks.has_access_to_sensitive_data]", ObjectSerializer_1.ObjectSerializer.serialize(filterRisksHasAccessToSensitiveData, "boolean", ""), "");
+            }
+            if (filterEnvironments !== undefined) {
+                requestContext.setQueryParam("filter[environments]", ObjectSerializer_1.ObjectSerializer.serialize(filterEnvironments, "string", ""), "");
+            }
+            if (filterArch !== undefined) {
+                requestContext.setQueryParam("filter[arch]", ObjectSerializer_1.ObjectSerializer.serialize(filterArch, "string", ""), "");
+            }
+            if (filterOperatingSystemName !== undefined) {
+                requestContext.setQueryParam("filter[operating_system.name]", ObjectSerializer_1.ObjectSerializer.serialize(filterOperatingSystemName, "string", ""), "");
+            }
+            if (filterOperatingSystemVersion !== undefined) {
+                requestContext.setQueryParam("filter[operating_system.version]", ObjectSerializer_1.ObjectSerializer.serialize(filterOperatingSystemVersion, "string", ""), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    muteFindings(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'muteFindings'");
+            if (!_config.unstableOperations["v2.muteFindings"]) {
+                throw new Error("Unstable operation 'muteFindings' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "muteFindings");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/posture_management/findings";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.muteFindings")
+                .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, "BulkMuteFindingsRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    patchSignalNotificationRule(id, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "patchSignalNotificationRule");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "patchSignalNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/signals/notification_rules/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.patchSignalNotificationRule")
+                .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, "PatchNotificationRuleParameters", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    patchVulnerabilityNotificationRule(id, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "patchVulnerabilityNotificationRule");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "patchVulnerabilityNotificationRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security/vulnerabilities/notification_rules/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.patchVulnerabilityNotificationRule")
+                .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, "PatchNotificationRuleParameters", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    runHistoricalJob(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'runHistoricalJob'");
+            if (!_config.unstableOperations["v2.runHistoricalJob"]) {
+                throw new Error("Unstable operation 'runHistoricalJob' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "runHistoricalJob");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/siem-historical-detections/jobs";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.runHistoricalJob")
+                .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",
@@ -1104,27 +1664,548 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
-}
-exports.SecurityMonitoringApiRequestFactory = SecurityMonitoringApiRequestFactory;
-class SecurityMonitoringApiResponseProcessor {
+}
+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 cancelHistoricalJob
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    cancelHistoricalJob(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 === 401 ||
+                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), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to convertExistingSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertExistingSecurityMonitoringRule(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), "SecurityMonitoringRuleConvertResponse");
+                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), "SecurityMonitoringRuleConvertResponse", "");
+                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 convertJobResultToSignal
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertJobResultToSignal(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 === 401 ||
+                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), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to convertSecurityMonitoringRuleFromJSONToTerraform
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertSecurityMonitoringRuleFromJSONToTerraform(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), "SecurityMonitoringRuleConvertResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                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), "SecurityMonitoringRuleConvertResponse", "");
+                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 createSecurityFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSecurityFilter(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), "SecurityFilterResponse");
+                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), "SecurityFilterResponse", "");
+                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 createSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSecurityMonitoringRule(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), "SecurityMonitoringRuleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.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), "SecurityMonitoringRuleResponse", "");
+                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 createSecurityMonitoringSuppression
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSecurityMonitoringSuppression(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), "SecurityMonitoringSuppressionResponse");
+                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), "SecurityMonitoringSuppressionResponse", "");
+                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 createSignalNotificationRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSignalNotificationRule(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), "NotificationRuleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.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), "NotificationRuleResponse", "");
+                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 createVulnerabilityNotificationRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createVulnerabilityNotificationRule(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), "NotificationRuleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.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), "NotificationRuleResponse", "");
+                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 deleteHistoricalJob
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteHistoricalJob(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 === 401 ||
+                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), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteSecurityFilter
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteSecurityFilter(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) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteSecurityMonitoringRule(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) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteSecurityMonitoringSuppression
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteSecurityMonitoringSuppression(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) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteSignalNotificationRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteSignalNotificationRule(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) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
      *
-     * @params response Response returned by the server for a request to cancelHistoricalJob
+     * @params response Response returned by the server for a request to deleteVulnerabilityNotificationRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    cancelHistoricalJob(response) {
+    deleteVulnerabilityNotificationRule(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 === 401 ||
-                response.httpStatusCode === 403 ||
+            if (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;
@@ -1150,14 +2231,14 @@ 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 convertExistingSecurityMonitoringRule
+     * @params response Response returned by the server for a request to editSecurityMonitoringSignalAssignee
      * @throws ApiException if the response code was not in [200, 299]
      */
-    convertExistingSecurityMonitoringRule(response) {
+    editSecurityMonitoringSignalAssignee(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), "SecurityMonitoringRuleConvertResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalTriageUpdateResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -1177,7 +2258,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringRuleConvertResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalTriageUpdateResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1188,17 +2269,17 @@ 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 convertJobResultToSignal
+     * @params response Response returned by the server for a request to editSecurityMonitoringSignalIncidents
      * @throws ApiException if the response code was not in [200, 299]
      */
-    convertJobResultToSignal(response) {
+    editSecurityMonitoringSignalIncidents(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 === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalTriageUpdateResponse");
+                return body;
             }
             if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
                 response.httpStatusCode === 403 ||
                 response.httpStatusCode === 404 ||
                 response.httpStatusCode === 429) {
@@ -1215,7 +2296,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalTriageUpdateResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1226,18 +2307,17 @@ 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 convertSecurityMonitoringRuleFromJSONToTerraform
+     * @params response Response returned by the server for a request to editSecurityMonitoringSignalState
      * @throws ApiException if the response code was not in [200, 299]
      */
-    convertSecurityMonitoringRuleFromJSONToTerraform(response) {
+    editSecurityMonitoringSignalState(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), "SecurityMonitoringRuleConvertResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalTriageUpdateResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
                 response.httpStatusCode === 403 ||
                 response.httpStatusCode === 404 ||
                 response.httpStatusCode === 429) {
@@ -1254,7 +2334,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringRuleConvertResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalTriageUpdateResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1265,24 +2345,24 @@ 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 createSecurityFilter
+     * @params response Response returned by the server for a request to getFinding
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createSecurityFilter(response) {
+    getFinding(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), "SecurityFilterResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetFindingResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 403 ||
-                response.httpStatusCode === 409 ||
+                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");
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
                 }
                 catch (error) {
                     logger_1.logger.debug(`Got error deserializing error: ${error}`);
@@ -1292,7 +2372,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityFilterResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetFindingResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1303,18 +2383,19 @@ 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 createSecurityMonitoringRule
+     * @params response Response returned by the server for a request to getHistoricalJob
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createSecurityMonitoringRule(response) {
+    getHistoricalJob(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), "SecurityMonitoringRuleResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "HistoricalJobResponse");
                 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;
@@ -1329,7 +2410,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringRuleResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "HistoricalJobResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1340,19 +2421,19 @@ 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 createSecurityMonitoringSuppression
+     * @params response Response returned by the server for a request to getRuleVersionHistory
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createSecurityMonitoringSuppression(response) {
+    getRuleVersionHistory(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), "SecurityMonitoringSuppressionResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetRuleVersionHistoryResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 403 ||
-                response.httpStatusCode === 409 ||
+                response.httpStatusCode === 404 ||
                 response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
@@ -1367,7 +2448,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSuppressionResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetRuleVersionHistoryResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1378,21 +2459,31 @@ 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 deleteHistoricalJob
+     * @params response Response returned by the server for a request to getSBOM
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteHistoricalJob(response) {
+    getSBOM(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 === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetSBOMResponse");
+                return body;
             }
             if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
                 response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 409 ||
-                response.httpStatusCode === 429) {
+                response.httpStatusCode === 404) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1406,7 +2497,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "GetSBOMResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1417,14 +2508,15 @@ 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 deleteSecurityFilter
+     * @params response Response returned by the server for a request to getSecurityFilter
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteSecurityFilter(response) {
+    getSecurityFilter(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 === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityFilterResponse");
+                return body;
             }
             if (response.httpStatusCode === 403 ||
                 response.httpStatusCode === 404 ||
@@ -1442,7 +2534,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityFilterResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1453,18 +2545,17 @@ 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 deleteSecurityMonitoringRule
+     * @params response Response returned by the server for a request to getSecurityMonitoringRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteSecurityMonitoringRule(response) {
+    getSecurityMonitoringRule(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 === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleResponse");
+                return body;
             }
-            if (response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 404 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1478,7 +2569,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1489,18 +2580,17 @@ 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 deleteSecurityMonitoringSuppression
+     * @params response Response returned by the server for a request to getSecurityMonitoringSignal
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteSecurityMonitoringSuppression(response) {
+    getSecurityMonitoringSignal(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 === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalResponse");
+                return body;
             }
-            if (response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 404 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1514,7 +2604,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "void", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1525,18 +2615,17 @@ 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 editSecurityMonitoringSignalAssignee
+     * @params response Response returned by the server for a request to getSecurityMonitoringSuppression
      * @throws ApiException if the response code was not in [200, 299]
      */
-    editSecurityMonitoringSignalAssignee(response) {
+    getSecurityMonitoringSuppression(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), "SecurityMonitoringSignalTriageUpdateResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSuppressionResponse");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 403 ||
+            if (response.httpStatusCode === 403 ||
                 response.httpStatusCode === 404 ||
                 response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
@@ -1552,7 +2641,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSignalTriageUpdateResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSuppressionResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1563,14 +2652,14 @@ 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 editSecurityMonitoringSignalIncidents
+     * @params response Response returned by the server for a request to getSignalNotificationRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    editSecurityMonitoringSignalIncidents(response) {
+    getSignalNotificationRule(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), "SecurityMonitoringSignalTriageUpdateResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -1590,7 +2679,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSignalTriageUpdateResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1601,20 +2690,17 @@ 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 editSecurityMonitoringSignalState
+     * @params response Response returned by the server for a request to getSignalNotificationRules
      * @throws ApiException if the response code was not in [200, 299]
      */
-    editSecurityMonitoringSignalState(response) {
+    getSignalNotificationRules(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), "SecurityMonitoringSignalTriageUpdateResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "any");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 403 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1628,7 +2714,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSignalTriageUpdateResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "any", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1639,14 +2725,14 @@ 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 getFinding
+     * @params response Response returned by the server for a request to getVulnerabilityNotificationRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getFinding(response) {
+    getVulnerabilityNotificationRule(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), "GetFindingResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
@@ -1656,7 +2742,7 @@ class SecurityMonitoringApiResponseProcessor {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
-                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
                 }
                 catch (error) {
                     logger_1.logger.debug(`Got error deserializing error: ${error}`);
@@ -1666,7 +2752,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "GetFindingResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1677,20 +2763,17 @@ 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 getHistoricalJob
+     * @params response Response returned by the server for a request to getVulnerabilityNotificationRules
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getHistoricalJob(response) {
+    getVulnerabilityNotificationRules(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), "HistoricalJobResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "any");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 403 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1704,7 +2787,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "HistoricalJobResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "any", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1715,23 +2798,24 @@ 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 getSecurityFilter
+     * @params response Response returned by the server for a request to listFindings
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getSecurityFilter(response) {
+    listFindings(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), "SecurityFilterResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListFindingsResponse");
                 return body;
             }
-            if (response.httpStatusCode === 403 ||
+            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");
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
                 }
                 catch (error) {
                     logger_1.logger.debug(`Got error deserializing error: ${error}`);
@@ -1741,7 +2825,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityFilterResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListFindingsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1752,17 +2836,19 @@ 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 getSecurityMonitoringRule
+     * @params response Response returned by the server for a request to listHistoricalJobs
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getSecurityMonitoringRule(response) {
+    listHistoricalJobs(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), "SecurityMonitoringRuleResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListHistoricalJobsResponse");
                 return body;
             }
-            if (response.httpStatusCode === 404 || response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1776,7 +2862,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringRuleResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListHistoricalJobsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1787,17 +2873,17 @@ 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 getSecurityMonitoringSignal
+     * @params response Response returned by the server for a request to listSecurityFilters
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getSecurityMonitoringSignal(response) {
+    listSecurityFilters(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), "SecurityMonitoringSignalResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityFiltersResponse");
                 return body;
             }
-            if (response.httpStatusCode === 404 || response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 403 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1811,7 +2897,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSignalResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityFiltersResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1822,19 +2908,17 @@ 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 getSecurityMonitoringSuppression
+     * @params response Response returned by the server for a request to listSecurityMonitoringRules
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getSecurityMonitoringSuppression(response) {
+    listSecurityMonitoringRules(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), "SecurityMonitoringSuppressionResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringListRulesResponse");
                 return body;
             }
-            if (response.httpStatusCode === 403 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1848,7 +2932,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSuppressionResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringListRulesResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1859,24 +2943,23 @@ 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 listFindings
+     * @params response Response returned by the server for a request to listSecurityMonitoringSignals
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listFindings(response) {
+    listSecurityMonitoringSignals(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), "ListFindingsResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalsListResponse");
                 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, "JSONAPIErrorResponse");
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
                 }
                 catch (error) {
                     logger_1.logger.debug(`Got error deserializing error: ${error}`);
@@ -1886,7 +2969,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "ListFindingsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSignalsListResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1897,19 +2980,17 @@ 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 listHistoricalJobs
+     * @params response Response returned by the server for a request to listSecurityMonitoringSuppressions
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listHistoricalJobs(response) {
+    listSecurityMonitoringSuppressions(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), "ListHistoricalJobsResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSuppressionsResponse");
                 return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 403 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 403 || response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1923,7 +3004,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "ListHistoricalJobsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringSuppressionsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1934,17 +3015,31 @@ 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 listSecurityFilters
+     * @params response Response returned by the server for a request to listVulnerabilities
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listSecurityFilters(response) {
+    listVulnerabilities(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), "SecurityFiltersResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListVulnerabilitiesResponse");
                 return body;
             }
-            if (response.httpStatusCode === 403 || response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1958,7 +3053,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityFiltersResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListVulnerabilitiesResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -1969,17 +3064,31 @@ 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 listSecurityMonitoringRules
+     * @params response Response returned by the server for a request to listVulnerableAssets
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listSecurityMonitoringRules(response) {
+    listVulnerableAssets(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), "SecurityMonitoringListRulesResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListVulnerableAssetsResponse");
                 return body;
             }
-            if (response.httpStatusCode === 400 || response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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);
+            }
+            if (response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1993,7 +3102,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringListRulesResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ListVulnerableAssetsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2004,23 +3113,25 @@ 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 listSecurityMonitoringSignals
+     * @params response Response returned by the server for a request to muteFindings
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listSecurityMonitoringSignals(response) {
+    muteFindings(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), "SecurityMonitoringSignalsListResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "BulkMuteFindingsResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 422 ||
                 response.httpStatusCode === 429) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
-                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
                 }
                 catch (error) {
                     logger_1.logger.debug(`Got error deserializing error: ${error}`);
@@ -2030,7 +3141,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "SecurityMonitoringSignalsListResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "BulkMuteFindingsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2041,17 +3152,20 @@ 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 listSecurityMonitoringSuppressions
+     * @params response Response returned by the server for a request to patchSignalNotificationRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listSecurityMonitoringSuppressions(response) {
+    patchSignalNotificationRule(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), "SecurityMonitoringSuppressionsResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse");
                 return body;
             }
-            if (response.httpStatusCode === 403 || response.httpStatusCode === 429) {
+            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 {
@@ -2063,9 +3177,21 @@ class SecurityMonitoringApiResponseProcessor {
                 }
                 throw new exception_1.ApiException(response.httpStatusCode, body);
             }
+            if (response.httpStatusCode === 422) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "JSONAPIErrorResponse");
+                }
+                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), "SecurityMonitoringSuppressionsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2076,21 +3202,32 @@ 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 muteFindings
+     * @params response Response returned by the server for a request to patchVulnerabilityNotificationRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    muteFindings(response) {
+    patchVulnerabilityNotificationRule(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), "BulkMuteFindingsResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 403 ||
                 response.httpStatusCode === 404 ||
-                response.httpStatusCode === 422 ||
                 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);
+            }
+            if (response.httpStatusCode === 422) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -2104,7 +3241,7 @@ class SecurityMonitoringApiResponseProcessor {
             }
             // 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), "BulkMuteFindingsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "NotificationRuleResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -2531,6 +3668,34 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Create a new notification rule for security signals and return the created rule.
+     * @param param The request object
+     */
+    createSignalNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.createSignalNotificationRule(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createSignalNotificationRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Create a new notification rule for security vulnerabilities and return the created rule.
+     * @param param The request object
+     */
+    createVulnerabilityNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.createVulnerabilityNotificationRule(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createVulnerabilityNotificationRule(responseContext);
+            });
+        });
+    }
     /**
      * Delete an existing job.
      * @param param The request object
@@ -2587,6 +3752,34 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Delete a notification rule for security signals.
+     * @param param The request object
+     */
+    deleteSignalNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.deleteSignalNotificationRule(param.id, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteSignalNotificationRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Delete a notification rule for security vulnerabilities.
+     * @param param The request object
+     */
+    deleteVulnerabilityNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.deleteVulnerabilityNotificationRule(param.id, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteVulnerabilityNotificationRule(responseContext);
+            });
+        });
+    }
     /**
      * Modify the triage assignee of a security signal.
      * @param param The request object
@@ -2657,6 +3850,34 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Get a rule's version history.
+     * @param param The request object
+     */
+    getRuleVersionHistory(param, options) {
+        const requestContextPromise = this.requestFactory.getRuleVersionHistory(param.ruleId, param.pageSize, param.pageNumber, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getRuleVersionHistory(responseContext);
+            });
+        });
+    }
+    /**
+     * Get a single SBOM related to an asset by its type and name.
+     * @param param The request object
+     */
+    getSBOM(param, options) {
+        const requestContextPromise = this.requestFactory.getSBOM(param.assetType, param.filterAssetName, param.filterRepoDigest, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getSBOM(responseContext);
+            });
+        });
+    }
     /**
      * Get the details of a specific security filter.
      *
@@ -2716,6 +3937,62 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Get the details of a notification rule for security signals.
+     * @param param The request object
+     */
+    getSignalNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.getSignalNotificationRule(param.id, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getSignalNotificationRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Returns the list of notification rules for security signals.
+     * @param param The request object
+     */
+    getSignalNotificationRules(options) {
+        const requestContextPromise = this.requestFactory.getSignalNotificationRules(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getSignalNotificationRules(responseContext);
+            });
+        });
+    }
+    /**
+     * Get the details of a notification rule for security vulnerabilities.
+     * @param param The request object
+     */
+    getVulnerabilityNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.getVulnerabilityNotificationRule(param.id, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getVulnerabilityNotificationRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Returns the list of notification rules for security vulnerabilities.
+     * @param param The request object
+     */
+    getVulnerabilityNotificationRules(options) {
+        const requestContextPromise = this.requestFactory.getVulnerabilityNotificationRules(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getVulnerabilityNotificationRules(responseContext);
+            });
+        });
+    }
     /**
      * Get a list of findings. These include both misconfigurations and identity risks.
      *
@@ -2915,6 +4192,125 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Get a list of vulnerabilities.
+     *
+     * ### Pagination
+     *
+     * Pagination is enabled by default in both `vulnerabilities` and `assets`. The size of the page varies depending on the endpoint and cannot be modified. To automate the request of the next page, you can use the links section in the response.
+     *
+     * This endpoint will return paginated responses. The pages are stored in the links section of the response:
+     *
+     * ```JSON
+     * {
+     *   "data": [...],
+     *   "meta": {...},
+     *   "links": {
+     *     "self": "https://.../api/v2/security/vulnerabilities",
+     *     "first": "https://.../api/v2/security/vulnerabilities?page[number]=1&page[token]=abc",
+     *     "last": "https://.../api/v2/security/vulnerabilities?page[number]=43&page[token]=abc",
+     *     "next": "https://.../api/v2/security/vulnerabilities?page[number]=2&page[token]=abc"
+     *   }
+     * }
+     * ```
+     *
+     *
+     * - `links.previous` is empty if the first page is requested.
+     * - `links.next` is empty if the last page is requested.
+     *
+     * #### Token
+     *
+     * Vulnerabilities can be created, updated or deleted at any point in time.
+     *
+     * Upon the first request, a token is created to ensure consistency across subsequent paginated requests.
+     *
+     * A token is valid only for 24 hours.
+     *
+     * #### First request
+     *
+     * We consider a request to be the first request when there is no `page[token]` parameter.
+     *
+     * The response of this first request contains the newly created token in the `links` section.
+     *
+     * This token can then be used in the subsequent paginated requests.
+     *
+     * #### Subsequent requests
+     *
+     * Any request containing valid `page[token]` and `page[number]` parameters will be considered a subsequent request.
+     *
+     * If the `token` is invalid, a `404` response will be returned.
+     *
+     * If the page `number` is invalid, a `400` response will be returned.
+     *
+     * ### Filtering
+     *
+     * The request can include some filter parameters to filter the data to be retrieved. The format of the filter parameters follows the [JSON:API format](https://jsonapi.org/format/#fetching-filtering): `filter[$prop_name]`, where `prop_name` is the property name in the entity being filtered by.
+     *
+     * All filters can include multiple values, where data will be filtered with an OR clause: `filter[title]=Title1,Title2` will filter all vulnerabilities where title is equal to `Title1` OR `Title2`.
+     *
+     * String filters are case sensitive.
+     *
+     * Boolean filters accept `true` or `false` as values.
+     *
+     * Number filters must include an operator as a second filter input: `filter[$prop_name][$operator]`. For example, for the vulnerabilities endpoint: `filter[cvss.base.score][lte]=8`.
+     *
+     * Available operators are: `eq` (==), `lt` (<), `lte` (<=), `gt` (>) and `gte` (>=).
+     *
+     * ### Metadata
+     *
+     * Following [JSON:API format](https://jsonapi.org/format/#document-meta), object including non-standard meta-information.
+     *
+     * This endpoint includes the meta member in the response. For more details on each of the properties included in this section, check the endpoints response tables.
+     *
+     * ```JSON
+     * {
+     *   "data": [...],
+     *   "meta": {
+     *     "total": 1500,
+     *     "count": 18732,
+     *     "token": "some_token"
+     *   },
+     *   "links": {...}
+     * }
+     * ```
+     * @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.filterAssetName, param.filterAssetType, param.filterAssetVersionFirst, param.filterAssetVersionLast, param.filterAssetRepositoryUrl, param.filterAssetRisksInProduction, param.filterAssetRisksUnderAttack, param.filterAssetRisksIsPubliclyAccessible, param.filterAssetRisksHasPrivilegedAccess, param.filterAssetRisksHasAccessToSensitiveData, param.filterAssetEnvironments, param.filterAssetArch, param.filterAssetOperatingSystemName, param.filterAssetOperatingSystemVersion, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listVulnerabilities(responseContext);
+            });
+        });
+    }
+    /**
+     * Get a list of vulnerable assets.
+     *
+     * ### Pagination
+     *
+     * Please review the [Pagination section for the "List Vulnerabilities"](#pagination) endpoint.
+     *
+     * ### Filtering
+     *
+     * Please review the [Filtering section for the "List Vulnerabilities"](#filtering) endpoint.
+     *
+     * ### Metadata
+     *
+     * Please review the [Metadata section for the "List Vulnerabilities"](#metadata) endpoint.
+     * @param param The request object
+     */
+    listVulnerableAssets(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listVulnerableAssets(param.pageToken, param.pageNumber, param.filterName, param.filterType, param.filterVersionFirst, param.filterVersionLast, param.filterRepositoryUrl, param.filterRisksInProduction, param.filterRisksUnderAttack, param.filterRisksIsPubliclyAccessible, param.filterRisksHasPrivilegedAccess, param.filterRisksHasAccessToSensitiveData, param.filterEnvironments, param.filterArch, param.filterOperatingSystemName, param.filterOperatingSystemVersion, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listVulnerableAssets(responseContext);
+            });
+        });
+    }
     /**
      * Mute or unmute findings.
      * @param param The request object
@@ -2929,6 +4325,34 @@ class SecurityMonitoringApi {
             });
         });
     }
+    /**
+     * Partially update the notification rule. All fields are optional; if a field is not provided, it is not updated.
+     * @param param The request object
+     */
+    patchSignalNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.patchSignalNotificationRule(param.id, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.patchSignalNotificationRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Partially update the notification rule. All fields are optional; if a field is not provided, it is not updated.
+     * @param param The request object
+     */
+    patchVulnerabilityNotificationRule(param, options) {
+        const requestContextPromise = this.requestFactory.patchVulnerabilityNotificationRule(param.id, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.patchVulnerabilityNotificationRule(responseContext);
+            });
+        });
+    }
     /**
      * Run a historical job.
      * @param param The request object