@datadog/datadog-api-client 1.58.0 → 1.59.0

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

@@ -29,6 +29,156 @@ const logger_1 = require("../../../logger");
 const ObjectSerializer_1 = require("../models/ObjectSerializer");
 const exception_1 = require("../../datadog-api-client-common/exception");
 class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    createAiCustomRule(rulesetName, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createAiCustomRule'");
+            if (!_config.unstableOperations["v2.createAiCustomRule"]) {
+                throw new Error("Unstable operation 'createAiCustomRule' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "createAiCustomRule");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createAiCustomRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules".replace("{ruleset_name}", encodeURIComponent(String(rulesetName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.createAiCustomRule")
+                .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, "AiCustomRuleRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createAiCustomRuleRevision(rulesetName, ruleName, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createAiCustomRuleRevision'");
+            if (!_config.unstableOperations["v2.createAiCustomRuleRevision"]) {
+                throw new Error("Unstable operation 'createAiCustomRuleRevision' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "createAiCustomRuleRevision");
+            }
+            // verify required parameter 'ruleName' is not null or undefined
+            if (ruleName === null || ruleName === undefined) {
+                throw new baseapi_1.RequiredError("ruleName", "createAiCustomRuleRevision");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createAiCustomRuleRevision");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}/revisions"
+                .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
+                .replace("{rule_name}", encodeURIComponent(String(ruleName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.createAiCustomRuleRevision")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "AiCustomRuleRevisionRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createAiCustomRuleset(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createAiCustomRuleset'");
+            if (!_config.unstableOperations["v2.createAiCustomRuleset"]) {
+                throw new Error("Unstable operation 'createAiCustomRuleset' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createAiCustomRuleset");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.createAiCustomRuleset")
+                .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, "AiCustomRulesetRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    createAiMemoryViolationResult(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createAiMemoryViolationResult'");
+            if (!_config.unstableOperations["v2.createAiMemoryViolationResult"]) {
+                throw new Error("Unstable operation 'createAiMemoryViolationResult' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createAiMemoryViolationResult");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/memory";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.createAiMemoryViolationResult")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.POST);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "AiMemoryViolationResultRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     createCustomRule(rulesetName, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -111,6 +261,41 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    createCustomRuleset(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createCustomRuleset'");
+            if (!_config.unstableOperations["v2.createCustomRuleset"]) {
+                throw new Error("Unstable operation 'createCustomRuleset' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createCustomRuleset");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/custom/rulesets";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.createCustomRuleset")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PUT);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "CustomRulesetRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
     createSCAResolveVulnerableSymbols(body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -181,6 +366,128 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    createSCAScan(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'createSCAScan'");
+            if (!_config.unstableOperations["v2.createSCAScan"]) {
+                throw new Error("Unstable operation 'createSCAScan' is disabled");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "createSCAScan");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis-sca/dependencies/scan";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.createSCAScan")
+                .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, "McpScanRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
+    deleteAiCustomRule(rulesetName, ruleName, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'deleteAiCustomRule'");
+            if (!_config.unstableOperations["v2.deleteAiCustomRule"]) {
+                throw new Error("Unstable operation 'deleteAiCustomRule' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "deleteAiCustomRule");
+            }
+            // verify required parameter 'ruleName' is not null or undefined
+            if (ruleName === null || ruleName === undefined) {
+                throw new baseapi_1.RequiredError("ruleName", "deleteAiCustomRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}"
+                .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
+                .replace("{rule_name}", encodeURIComponent(String(ruleName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.deleteAiCustomRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    deleteAiCustomRuleset(rulesetName, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'deleteAiCustomRuleset'");
+            if (!_config.unstableOperations["v2.deleteAiCustomRuleset"]) {
+                throw new Error("Unstable operation 'deleteAiCustomRuleset' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "deleteAiCustomRuleset");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}".replace("{ruleset_name}", encodeURIComponent(String(rulesetName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.deleteAiCustomRuleset")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    deleteAiMemoryViolationResult(id, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'deleteAiMemoryViolationResult'");
+            if (!_config.unstableOperations["v2.deleteAiMemoryViolationResult"]) {
+                throw new Error("Unstable operation 'deleteAiMemoryViolationResult' is disabled");
+            }
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "deleteAiMemoryViolationResult");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/memory/{id}".replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.deleteAiMemoryViolationResult")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.DELETE);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     deleteCustomRule(rulesetName, ruleName, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -241,28 +548,28 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
-    getCustomRule(rulesetName, ruleName, _options) {
+    getAiCustomRule(rulesetName, ruleName, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'getCustomRule'");
-            if (!_config.unstableOperations["v2.getCustomRule"]) {
-                throw new Error("Unstable operation 'getCustomRule' is disabled");
+            logger_1.logger.warn("Using unstable operation 'getAiCustomRule'");
+            if (!_config.unstableOperations["v2.getAiCustomRule"]) {
+                throw new Error("Unstable operation 'getAiCustomRule' is disabled");
             }
             // verify required parameter 'rulesetName' is not null or undefined
             if (rulesetName === null || rulesetName === undefined) {
-                throw new baseapi_1.RequiredError("rulesetName", "getCustomRule");
+                throw new baseapi_1.RequiredError("rulesetName", "getAiCustomRule");
             }
             // verify required parameter 'ruleName' is not null or undefined
             if (ruleName === null || ruleName === undefined) {
-                throw new baseapi_1.RequiredError("ruleName", "getCustomRule");
+                throw new baseapi_1.RequiredError("ruleName", "getAiCustomRule");
             }
             // Path Params
-            const localVarPath = "/api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}"
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}"
                 .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
                 .replace("{rule_name}", encodeURIComponent(String(ruleName)));
             // Make Request Context
             const requestContext = _config
-                .getServer("v2.StaticAnalysisApi.getCustomRule")
+                .getServer("v2.StaticAnalysisApi.getAiCustomRule")
                 .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
             requestContext.setHeaderParam("Accept", "application/json");
             requestContext.setHttpConfig(_config.httpConfig);
@@ -274,33 +581,33 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
-    getCustomRuleRevision(rulesetName, ruleName, id, _options) {
+    getAiCustomRuleRevision(rulesetName, ruleName, id, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'getCustomRuleRevision'");
-            if (!_config.unstableOperations["v2.getCustomRuleRevision"]) {
-                throw new Error("Unstable operation 'getCustomRuleRevision' is disabled");
+            logger_1.logger.warn("Using unstable operation 'getAiCustomRuleRevision'");
+            if (!_config.unstableOperations["v2.getAiCustomRuleRevision"]) {
+                throw new Error("Unstable operation 'getAiCustomRuleRevision' is disabled");
             }
             // verify required parameter 'rulesetName' is not null or undefined
             if (rulesetName === null || rulesetName === undefined) {
-                throw new baseapi_1.RequiredError("rulesetName", "getCustomRuleRevision");
+                throw new baseapi_1.RequiredError("rulesetName", "getAiCustomRuleRevision");
             }
             // verify required parameter 'ruleName' is not null or undefined
             if (ruleName === null || ruleName === undefined) {
-                throw new baseapi_1.RequiredError("ruleName", "getCustomRuleRevision");
+                throw new baseapi_1.RequiredError("ruleName", "getAiCustomRuleRevision");
             }
             // verify required parameter 'id' is not null or undefined
             if (id === null || id === undefined) {
-                throw new baseapi_1.RequiredError("id", "getCustomRuleRevision");
+                throw new baseapi_1.RequiredError("id", "getAiCustomRuleRevision");
             }
             // Path Params
-            const localVarPath = "/api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}/revisions/{id}"
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}/revisions/{id}"
                 .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
                 .replace("{rule_name}", encodeURIComponent(String(ruleName)))
                 .replace("{id}", encodeURIComponent(String(id)));
             // Make Request Context
             const requestContext = _config
-                .getServer("v2.StaticAnalysisApi.getCustomRuleRevision")
+                .getServer("v2.StaticAnalysisApi.getAiCustomRuleRevision")
                 .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
             requestContext.setHeaderParam("Accept", "application/json");
             requestContext.setHttpConfig(_config.httpConfig);
@@ -312,12 +619,110 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
-    getCustomRuleset(rulesetName, _options) {
+    getAiCustomRuleset(rulesetName, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'getCustomRuleset'");
-            if (!_config.unstableOperations["v2.getCustomRuleset"]) {
-                throw new Error("Unstable operation 'getCustomRuleset' is disabled");
+            logger_1.logger.warn("Using unstable operation 'getAiCustomRuleset'");
+            if (!_config.unstableOperations["v2.getAiCustomRuleset"]) {
+                throw new Error("Unstable operation 'getAiCustomRuleset' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "getAiCustomRuleset");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}".replace("{ruleset_name}", encodeURIComponent(String(rulesetName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.getAiCustomRuleset")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getCustomRule(rulesetName, ruleName, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getCustomRule'");
+            if (!_config.unstableOperations["v2.getCustomRule"]) {
+                throw new Error("Unstable operation 'getCustomRule' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "getCustomRule");
+            }
+            // verify required parameter 'ruleName' is not null or undefined
+            if (ruleName === null || ruleName === undefined) {
+                throw new baseapi_1.RequiredError("ruleName", "getCustomRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}"
+                .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
+                .replace("{rule_name}", encodeURIComponent(String(ruleName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.getCustomRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getCustomRuleRevision(rulesetName, ruleName, id, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getCustomRuleRevision'");
+            if (!_config.unstableOperations["v2.getCustomRuleRevision"]) {
+                throw new Error("Unstable operation 'getCustomRuleRevision' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "getCustomRuleRevision");
+            }
+            // verify required parameter 'ruleName' is not null or undefined
+            if (ruleName === null || ruleName === undefined) {
+                throw new baseapi_1.RequiredError("ruleName", "getCustomRuleRevision");
+            }
+            // verify required parameter 'id' is not null or undefined
+            if (id === null || id === undefined) {
+                throw new baseapi_1.RequiredError("id", "getCustomRuleRevision");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}/revisions/{id}"
+                .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
+                .replace("{rule_name}", encodeURIComponent(String(ruleName)))
+                .replace("{id}", encodeURIComponent(String(id)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.getCustomRuleRevision")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    getCustomRuleset(rulesetName, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getCustomRuleset'");
+            if (!_config.unstableOperations["v2.getCustomRuleset"]) {
+                throw new Error("Unstable operation 'getCustomRuleset' is disabled");
             }
             // verify required parameter 'rulesetName' is not null or undefined
             if (rulesetName === null || rulesetName === undefined) {
@@ -339,6 +744,150 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
+    getSCAScan(jobId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'getSCAScan'");
+            if (!_config.unstableOperations["v2.getSCAScan"]) {
+                throw new Error("Unstable operation 'getSCAScan' is disabled");
+            }
+            // verify required parameter 'jobId' is not null or undefined
+            if (jobId === null || jobId === undefined) {
+                throw new baseapi_1.RequiredError("jobId", "getSCAScan");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis-sca/dependencies/scan/{job_id}".replace("{job_id}", encodeURIComponent(String(jobId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.getSCAScan")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
+    listAiCustomRuleRevisions(rulesetName, ruleName, pageOffset, pageLimit, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listAiCustomRuleRevisions'");
+            if (!_config.unstableOperations["v2.listAiCustomRuleRevisions"]) {
+                throw new Error("Unstable operation 'listAiCustomRuleRevisions' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "listAiCustomRuleRevisions");
+            }
+            // verify required parameter 'ruleName' is not null or undefined
+            if (ruleName === null || ruleName === undefined) {
+                throw new baseapi_1.RequiredError("ruleName", "listAiCustomRuleRevisions");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}/revisions"
+                .replace("{ruleset_name}", encodeURIComponent(String(rulesetName)))
+                .replace("{rule_name}", encodeURIComponent(String(ruleName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.listAiCustomRuleRevisions")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (pageOffset !== undefined) {
+                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"), "");
+            }
+            if (pageLimit !== undefined) {
+                requestContext.setQueryParam("page[limit]", ObjectSerializer_1.ObjectSerializer.serialize(pageLimit, "number", "int64"), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listAiCustomRulesets(pageOffset, pageLimit, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listAiCustomRulesets'");
+            if (!_config.unstableOperations["v2.listAiCustomRulesets"]) {
+                throw new Error("Unstable operation 'listAiCustomRulesets' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.listAiCustomRulesets")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Query Params
+            if (pageOffset !== undefined) {
+                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"), "");
+            }
+            if (pageLimit !== undefined) {
+                requestContext.setQueryParam("page[limit]", ObjectSerializer_1.ObjectSerializer.serialize(pageLimit, "number", "int64"), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listAiMemoryViolationResults(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listAiMemoryViolationResults'");
+            if (!_config.unstableOperations["v2.listAiMemoryViolationResults"]) {
+                throw new Error("Unstable operation 'listAiMemoryViolationResults' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/memory";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.listAiMemoryViolationResults")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listAiPrompts(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listAiPrompts'");
+            if (!_config.unstableOperations["v2.listAiPrompts"]) {
+                throw new Error("Unstable operation 'listAiPrompts' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/prompts";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.listAiPrompts")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     listCustomRuleRevisions(rulesetName, ruleName, pageOffset, pageLimit, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -366,11 +915,58 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             requestContext.setHttpConfig(_config.httpConfig);
             // Query Params
             if (pageOffset !== undefined) {
-                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", ""), "");
+                requestContext.setQueryParam("page[offset]", ObjectSerializer_1.ObjectSerializer.serialize(pageOffset, "number", "int64"), "");
             }
             if (pageLimit !== undefined) {
-                requestContext.setQueryParam("page[limit]", ObjectSerializer_1.ObjectSerializer.serialize(pageLimit, "number", ""), "");
+                requestContext.setQueryParam("page[limit]", ObjectSerializer_1.ObjectSerializer.serialize(pageLimit, "number", "int64"), "");
+            }
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    listCustomRulesets(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listCustomRulesets'");
+            if (!_config.unstableOperations["v2.listCustomRulesets"]) {
+                throw new Error("Unstable operation 'listCustomRulesets' is disabled");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/custom/rulesets";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.listCustomRulesets")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+                "AuthZ",
+            ]);
+            return requestContext;
+        });
+    }
+    listSCALicenses(_options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'listSCALicenses'");
+            if (!_config.unstableOperations["v2.listSCALicenses"]) {
+                throw new Error("Unstable operation 'listSCALicenses' is disabled");
             }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis-sca/licenses/list";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.listSCALicenses")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
             // Apply auth methods
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
                 "apiKeyAuth",
@@ -423,55 +1019,941 @@ class StaticAnalysisApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
             return requestContext;
         });
     }
-    updateCustomRuleset(rulesetName, body, _options) {
+    updateAiCustomRuleset(rulesetName, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateAiCustomRuleset'");
+            if (!_config.unstableOperations["v2.updateAiCustomRuleset"]) {
+                throw new Error("Unstable operation 'updateAiCustomRuleset' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "updateAiCustomRuleset");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateAiCustomRuleset");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/ai/rulesets/{ruleset_name}".replace("{ruleset_name}", encodeURIComponent(String(rulesetName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.updateAiCustomRuleset")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.PATCH);
+            requestContext.setHeaderParam("Accept", "*/*");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Body Params
+            const contentType = ObjectSerializer_1.ObjectSerializer.getPreferredMediaType([
+                "application/json",
+            ]);
+            requestContext.setHeaderParam("Content-Type", contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "AiCustomRulesetUpdateRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    updateCustomRuleset(rulesetName, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            logger_1.logger.warn("Using unstable operation 'updateCustomRuleset'");
+            if (!_config.unstableOperations["v2.updateCustomRuleset"]) {
+                throw new Error("Unstable operation 'updateCustomRuleset' is disabled");
+            }
+            // verify required parameter 'rulesetName' is not null or undefined
+            if (rulesetName === null || rulesetName === undefined) {
+                throw new baseapi_1.RequiredError("rulesetName", "updateCustomRuleset");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "updateCustomRuleset");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/static-analysis/custom/rulesets/{ruleset_name}".replace("{ruleset_name}", encodeURIComponent(String(rulesetName)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.StaticAnalysisApi.updateCustomRuleset")
+                .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, "CustomRulesetRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+}
+exports.StaticAnalysisApiRequestFactory = StaticAnalysisApiRequestFactory;
+class StaticAnalysisApiResponseProcessor {
+    /**
+     * 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 createAiCustomRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createAiCustomRule(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), "AiCustomRuleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 409 ||
+                response.httpStatusCode === 412 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    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), "AiCustomRuleResponse", "");
+                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 createAiCustomRuleRevision
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createAiCustomRuleRevision(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createAiCustomRuleset
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createAiCustomRuleset(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), "AiCustomRulesetResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 409 ||
+                response.httpStatusCode === 412 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    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), "AiCustomRulesetResponse", "");
+                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 createAiMemoryViolationResult
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createAiMemoryViolationResult(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createCustomRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createCustomRule(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), "CustomRuleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 409 ||
+                response.httpStatusCode === 412) {
+                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 {
+                    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), "CustomRuleResponse", "");
+                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 createCustomRuleRevision
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createCustomRuleRevision(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createCustomRuleset
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createCustomRuleset(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), "CustomRulesetResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 409 ||
+                response.httpStatusCode === 412) {
+                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 {
+                    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), "CustomRulesetResponse", "");
+                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 createSCAResolveVulnerableSymbols
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSCAResolveVulnerableSymbols(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), "ResolveVulnerableSymbolsResponse");
+                return body;
+            }
+            if (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), "ResolveVulnerableSymbolsResponse", "");
+                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 createSCAResult
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSCAResult(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to createSCAScan
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    createSCAScan(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 202) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "McpScanRequestResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400) {
+                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 {
+                    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), "McpScanRequestResponse", "");
+                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 deleteAiCustomRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteAiCustomRule(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteAiCustomRuleset
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteAiCustomRuleset(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteAiMemoryViolationResult
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteAiMemoryViolationResult(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteCustomRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteCustomRule(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to deleteCustomRuleset
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    deleteCustomRuleset(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                return;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                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 {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                return;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to getAiCustomRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getAiCustomRule(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), "AiCustomRuleResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    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), "AiCustomRuleResponse", "");
+                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 getAiCustomRuleRevision
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getAiCustomRuleRevision(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), "AiCustomRuleRevisionResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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 {
+                    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), "AiCustomRuleRevisionResponse", "");
+                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 getAiCustomRuleset
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    getAiCustomRuleset(response) {
         return __awaiter(this, void 0, void 0, function* () {
-            const _config = _options || this.configuration;
-            logger_1.logger.warn("Using unstable operation 'updateCustomRuleset'");
-            if (!_config.unstableOperations["v2.updateCustomRuleset"]) {
-                throw new Error("Unstable operation 'updateCustomRuleset' is disabled");
+            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), "AiCustomRulesetResponse");
+                return body;
             }
-            // verify required parameter 'rulesetName' is not null or undefined
-            if (rulesetName === null || rulesetName === undefined) {
-                throw new baseapi_1.RequiredError("rulesetName", "updateCustomRuleset");
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
+                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);
             }
-            // verify required parameter 'body' is not null or undefined
-            if (body === null || body === undefined) {
-                throw new baseapi_1.RequiredError("body", "updateCustomRuleset");
+            if (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);
             }
-            // Path Params
-            const localVarPath = "/api/v2/static-analysis/custom/rulesets/{ruleset_name}".replace("{ruleset_name}", encodeURIComponent(String(rulesetName)));
-            // Make Request Context
-            const requestContext = _config
-                .getServer("v2.StaticAnalysisApi.updateCustomRuleset")
-                .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, "CustomRulesetRequest", ""), contentType);
-            requestContext.setBody(serializedBody);
-            // Apply auth methods
-            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
-                "apiKeyAuth",
-                "appKeyAuth",
-            ]);
-            return requestContext;
+            // 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), "AiCustomRulesetResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
-}
-exports.StaticAnalysisApiRequestFactory = StaticAnalysisApiRequestFactory;
-class StaticAnalysisApiResponseProcessor {
     /**
      * 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 createCustomRule
+     * @params response Response returned by the server for a request to getCustomRule
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createCustomRule(response) {
+    getCustomRule(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 200) {
@@ -480,8 +1962,7 @@ class StaticAnalysisApiResponseProcessor {
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 401 ||
-                response.httpStatusCode === 409 ||
-                response.httpStatusCode === 412) {
+                response.httpStatusCode === 404) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -518,14 +1999,15 @@ class StaticAnalysisApiResponseProcessor {
      * 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 createCustomRuleRevision
+     * @params response Response returned by the server for a request to getCustomRuleRevision
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createCustomRuleRevision(response) {
+    getCustomRuleRevision(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 200) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "CustomRuleRevisionResponse");
+                return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 401 ||
@@ -555,7 +2037,8 @@ class StaticAnalysisApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "CustomRuleRevisionResponse", "");
+                return body;
             }
             const body = (yield response.body.text()) || "";
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
@@ -565,16 +2048,30 @@ class StaticAnalysisApiResponseProcessor {
      * 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 createSCAResolveVulnerableSymbols
+     * @params response Response returned by the server for a request to getCustomRuleset
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createSCAResolveVulnerableSymbols(response) {
+    getCustomRuleset(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), "ResolveVulnerableSymbolsResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "CustomRulesetResponse");
                 return body;
             }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                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;
@@ -589,7 +2086,7 @@ class StaticAnalysisApiResponseProcessor {
             }
             // 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), "ResolveVulnerableSymbolsResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "CustomRulesetResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -600,14 +2097,27 @@ class StaticAnalysisApiResponseProcessor {
      * 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 createSCAResult
+     * @params response Response returned by the server for a request to getSCAScan
      * @throws ApiException if the response code was not in [200, 299]
      */
-    createSCAResult(response) {
+    getSCAScan(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 200) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ScanResultResponse");
+                return body;
+            }
+            if (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);
@@ -623,7 +2133,8 @@ class StaticAnalysisApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "ScanResultResponse", "");
+                return body;
             }
             const body = (yield response.body.text()) || "";
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
@@ -633,18 +2144,20 @@ class StaticAnalysisApiResponseProcessor {
      * 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 deleteCustomRule
+     * @params response Response returned by the server for a request to listAiCustomRuleRevisions
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteCustomRule(response) {
+    listAiCustomRuleRevisions(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 200) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiCustomRuleRevisionsResponse");
+                return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 401 ||
-                response.httpStatusCode === 404) {
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -670,7 +2183,8 @@ class StaticAnalysisApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiCustomRuleRevisionsResponse", "");
+                return body;
             }
             const body = (yield response.body.text()) || "";
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
@@ -680,18 +2194,17 @@ class StaticAnalysisApiResponseProcessor {
      * 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 deleteCustomRuleset
+     * @params response Response returned by the server for a request to listAiCustomRulesets
      * @throws ApiException if the response code was not in [200, 299]
      */
-    deleteCustomRuleset(response) {
+    listAiCustomRulesets(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 200) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiCustomRulesetsResponse");
+                return body;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
-                response.httpStatusCode === 404) {
+            if (response.httpStatusCode === 401 || response.httpStatusCode === 500) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -717,7 +2230,8 @@ class StaticAnalysisApiResponseProcessor {
             }
             // Work around for missing responses in specification, e.g. for petstore.yaml
             if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
-                return;
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiCustomRulesetsResponse", "");
+                return body;
             }
             const body = (yield response.body.text()) || "";
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
@@ -727,19 +2241,20 @@ class StaticAnalysisApiResponseProcessor {
      * 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 getCustomRule
+     * @params response Response returned by the server for a request to listAiMemoryViolationResults
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getCustomRule(response) {
+    listAiMemoryViolationResults(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), "CustomRuleResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiMemoryViolationResultsResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 401 ||
-                response.httpStatusCode === 404) {
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -765,7 +2280,7 @@ class StaticAnalysisApiResponseProcessor {
             }
             // 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), "CustomRuleResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiMemoryViolationResultsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -776,19 +2291,20 @@ class StaticAnalysisApiResponseProcessor {
      * 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 getCustomRuleRevision
+     * @params response Response returned by the server for a request to listAiPrompts
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getCustomRuleRevision(response) {
+    listAiPrompts(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), "CustomRuleRevisionResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiPromptsResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 401 ||
-                response.httpStatusCode === 404) {
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 500) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -814,7 +2330,7 @@ class StaticAnalysisApiResponseProcessor {
             }
             // 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), "CustomRuleRevisionResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "AiPromptsResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -825,19 +2341,55 @@ class StaticAnalysisApiResponseProcessor {
      * 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 getCustomRuleset
+     * @params response Response returned by the server for a request to listCustomRuleRevisions
      * @throws ApiException if the response code was not in [200, 299]
      */
-    getCustomRuleset(response) {
+    listCustomRuleRevisions(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), "CustomRulesetResponse");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "CustomRuleRevisionsResponse");
                 return body;
             }
             if (response.httpStatusCode === 400 ||
                 response.httpStatusCode === 401 ||
-                response.httpStatusCode === 404) {
+                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");
+                }
+                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), "CustomRuleRevisionsResponse", "");
+                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 listCustomRulesets
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    listCustomRulesets(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), "CustomRulesetListResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 401) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -863,7 +2415,7 @@ class StaticAnalysisApiResponseProcessor {
             }
             // 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), "CustomRulesetResponse", "");
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "CustomRulesetListResponse", "");
                 return body;
             }
             const body = (yield response.body.text()) || "";
@@ -874,20 +2426,51 @@ class StaticAnalysisApiResponseProcessor {
      * 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 listCustomRuleRevisions
+     * @params response Response returned by the server for a request to listSCALicenses
      * @throws ApiException if the response code was not in [200, 299]
      */
-    listCustomRuleRevisions(response) {
+    listSCALicenses(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), "LicensesListResponse");
+                return body;
+            }
+            if (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), "LicensesListResponse", "");
+                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 revertCustomRuleRevision
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    revertCustomRuleRevision(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), "CustomRuleRevisionsResponse");
-                return body;
+                return;
             }
-            if (response.httpStatusCode === 400 ||
-                response.httpStatusCode === 401 ||
-                response.httpStatusCode === 404 ||
-                response.httpStatusCode === 429) {
+            if (response.httpStatusCode === 400 || response.httpStatusCode === 401) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -899,10 +2482,21 @@ class StaticAnalysisApiResponseProcessor {
                 }
                 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 {
+                    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), "CustomRuleRevisionsResponse", "");
-                return body;
+                return;
             }
             const body = (yield response.body.text()) || "";
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
@@ -912,16 +2506,19 @@ class StaticAnalysisApiResponseProcessor {
      * 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 revertCustomRuleRevision
+     * @params response Response returned by the server for a request to updateAiCustomRuleset
      * @throws ApiException if the response code was not in [200, 299]
      */
-    revertCustomRuleRevision(response) {
+    updateAiCustomRuleset(response) {
         return __awaiter(this, void 0, void 0, function* () {
             const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
             if (response.httpStatusCode === 200) {
                 return;
             }
-            if (response.httpStatusCode === 400 || response.httpStatusCode === 401) {
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 412 ||
+                response.httpStatusCode === 500) {
                 const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
                 let body;
                 try {
@@ -1012,6 +2609,62 @@ class StaticAnalysisApi {
         this.responseProcessor =
             responseProcessor || new StaticAnalysisApiResponseProcessor();
     }
+    /**
+     * Create a new AI custom rule within a ruleset.
+     * @param param The request object
+     */
+    createAiCustomRule(param, options) {
+        const requestContextPromise = this.requestFactory.createAiCustomRule(param.rulesetName, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createAiCustomRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Create a new revision for an AI custom rule.
+     * @param param The request object
+     */
+    createAiCustomRuleRevision(param, options) {
+        const requestContextPromise = this.requestFactory.createAiCustomRuleRevision(param.rulesetName, param.ruleName, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createAiCustomRuleRevision(responseContext);
+            });
+        });
+    }
+    /**
+     * Create a new AI custom ruleset for the authenticated organization.
+     * @param param The request object
+     */
+    createAiCustomRuleset(param, options) {
+        const requestContextPromise = this.requestFactory.createAiCustomRuleset(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createAiCustomRuleset(responseContext);
+            });
+        });
+    }
+    /**
+     * Add a new AI memory violation result for the authenticated organization.
+     * @param param The request object
+     */
+    createAiMemoryViolationResult(param, options) {
+        const requestContextPromise = this.requestFactory.createAiMemoryViolationResult(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createAiMemoryViolationResult(responseContext);
+            });
+        });
+    }
     /**
      * Create a new custom rule within a ruleset
      * @param param The request object
@@ -1040,6 +2693,20 @@ class StaticAnalysisApi {
             });
         });
     }
+    /**
+     * Create a new custom ruleset for the authenticated organization.
+     * @param param The request object
+     */
+    createCustomRuleset(param, options) {
+        const requestContextPromise = this.requestFactory.createCustomRuleset(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createCustomRuleset(responseContext);
+            });
+        });
+    }
     /**
      * @param param The request object
      */
@@ -1066,6 +2733,61 @@ class StaticAnalysisApi {
             });
         });
     }
+    /**
+     * @param param The request object
+     */
+    createSCAScan(param, options) {
+        const requestContextPromise = this.requestFactory.createSCAScan(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.createSCAScan(responseContext);
+            });
+        });
+    }
+    /**
+     * Delete an AI custom rule by name within a ruleset.
+     * @param param The request object
+     */
+    deleteAiCustomRule(param, options) {
+        const requestContextPromise = this.requestFactory.deleteAiCustomRule(param.rulesetName, param.ruleName, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteAiCustomRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Delete an AI custom ruleset by name.
+     * @param param The request object
+     */
+    deleteAiCustomRuleset(param, options) {
+        const requestContextPromise = this.requestFactory.deleteAiCustomRuleset(param.rulesetName, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteAiCustomRuleset(responseContext);
+            });
+        });
+    }
+    /**
+     * Delete an AI memory violation result by its numeric identifier.
+     * @param param The request object
+     */
+    deleteAiMemoryViolationResult(param, options) {
+        const requestContextPromise = this.requestFactory.deleteAiMemoryViolationResult(param.id, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.deleteAiMemoryViolationResult(responseContext);
+            });
+        });
+    }
     /**
      * Delete a custom rule
      * @param param The request object
@@ -1094,6 +2816,48 @@ class StaticAnalysisApi {
             });
         });
     }
+    /**
+     * Get an AI custom rule by name within a ruleset.
+     * @param param The request object
+     */
+    getAiCustomRule(param, options) {
+        const requestContextPromise = this.requestFactory.getAiCustomRule(param.rulesetName, param.ruleName, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getAiCustomRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Get a specific revision of an AI custom rule.
+     * @param param The request object
+     */
+    getAiCustomRuleRevision(param, options) {
+        const requestContextPromise = this.requestFactory.getAiCustomRuleRevision(param.rulesetName, param.ruleName, param.id, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getAiCustomRuleRevision(responseContext);
+            });
+        });
+    }
+    /**
+     * Get an AI custom ruleset by name.
+     * @param param The request object
+     */
+    getAiCustomRuleset(param, options) {
+        const requestContextPromise = this.requestFactory.getAiCustomRuleset(param.rulesetName, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getAiCustomRuleset(responseContext);
+            });
+        });
+    }
     /**
      * Get a custom rule by name
      * @param param The request object
@@ -1136,6 +2900,109 @@ class StaticAnalysisApi {
             });
         });
     }
+    /**
+     * @param param The request object
+     */
+    getSCAScan(param, options) {
+        const requestContextPromise = this.requestFactory.getSCAScan(param.jobId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.getSCAScan(responseContext);
+            });
+        });
+    }
+    /**
+     * Get all revisions for an AI custom rule.
+     * @param param The request object
+     */
+    listAiCustomRuleRevisions(param, options) {
+        const requestContextPromise = this.requestFactory.listAiCustomRuleRevisions(param.rulesetName, param.ruleName, param.pageOffset, param.pageLimit, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listAiCustomRuleRevisions(responseContext);
+            });
+        });
+    }
+    /**
+     * Provide a paginated version of listAiCustomRuleRevisions returning a generator with all the items.
+     */
+    listAiCustomRuleRevisionsWithPagination(param, options) {
+        return __asyncGenerator(this, arguments, function* listAiCustomRuleRevisionsWithPagination_1() {
+            let pageSize = 100;
+            if (param.pageLimit !== undefined) {
+                pageSize = param.pageLimit;
+            }
+            param.pageLimit = pageSize;
+            while (true) {
+                const requestContext = yield __await(this.requestFactory.listAiCustomRuleRevisions(param.rulesetName, param.ruleName, param.pageOffset, param.pageLimit, options));
+                const responseContext = yield __await(this.configuration.httpApi.send(requestContext));
+                const response = yield __await(this.responseProcessor.listAiCustomRuleRevisions(responseContext));
+                const responseData = response.data;
+                if (responseData === undefined) {
+                    break;
+                }
+                const results = responseData;
+                for (const item of results) {
+                    yield yield __await(item);
+                }
+                if (results.length < pageSize) {
+                    break;
+                }
+                if (param.pageOffset === undefined) {
+                    param.pageOffset = pageSize;
+                }
+                else {
+                    param.pageOffset = param.pageOffset + pageSize;
+                }
+            }
+        });
+    }
+    /**
+     * Get all AI custom rulesets for the authenticated organization.
+     * @param param The request object
+     */
+    listAiCustomRulesets(param = {}, options) {
+        const requestContextPromise = this.requestFactory.listAiCustomRulesets(param.pageOffset, param.pageLimit, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listAiCustomRulesets(responseContext);
+            });
+        });
+    }
+    /**
+     * Get all AI memory violation results for the authenticated organization.
+     * @param param The request object
+     */
+    listAiMemoryViolationResults(options) {
+        const requestContextPromise = this.requestFactory.listAiMemoryViolationResults(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listAiMemoryViolationResults(responseContext);
+            });
+        });
+    }
+    /**
+     * Get all AI prompts, including default prompts and custom AI rule prompts for the authenticated organization.
+     * @param param The request object
+     */
+    listAiPrompts(options) {
+        const requestContextPromise = this.requestFactory.listAiPrompts(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listAiPrompts(responseContext);
+            });
+        });
+    }
     /**
      * Get all revisions for a custom rule
      * @param param The request object
@@ -1184,6 +3051,33 @@ class StaticAnalysisApi {
             }
         });
     }
+    /**
+     * Get all custom rulesets for the authenticated organization.
+     * @param param The request object
+     */
+    listCustomRulesets(options) {
+        const requestContextPromise = this.requestFactory.listCustomRulesets(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listCustomRulesets(responseContext);
+            });
+        });
+    }
+    /**
+     * @param param The request object
+     */
+    listSCALicenses(options) {
+        const requestContextPromise = this.requestFactory.listSCALicenses(options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.listSCALicenses(responseContext);
+            });
+        });
+    }
     /**
      * Revert a custom rule to a previous revision
      * @param param The request object
@@ -1198,6 +3092,20 @@ class StaticAnalysisApi {
             });
         });
     }
+    /**
+     * Update the description of an existing AI custom ruleset.
+     * @param param The request object
+     */
+    updateAiCustomRuleset(param, options) {
+        const requestContextPromise = this.requestFactory.updateAiCustomRuleset(param.rulesetName, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.updateAiCustomRuleset(responseContext);
+            });
+        });
+    }
     /**
      * Update an existing custom ruleset
      * @param param The request object