@rio-cloud/cdk-v2-constructs 6.12.0 → 6.12.2

package/node_modules/@datadog/datadog-api-client/dist/packages/datadog-api-client-v2/apis/SecurityMonitoringApi.d.ts

@@ -13,9 +13,14 @@ import { SecurityFilterResponse } from "../models/SecurityFilterResponse";
 import { SecurityFiltersResponse } from "../models/SecurityFiltersResponse";
 import { SecurityFilterUpdateRequest } from "../models/SecurityFilterUpdateRequest";
 import { SecurityMonitoringListRulesResponse } from "../models/SecurityMonitoringListRulesResponse";
+import { SecurityMonitoringRuleConvertPayload } from "../models/SecurityMonitoringRuleConvertPayload";
+import { SecurityMonitoringRuleConvertResponse } from "../models/SecurityMonitoringRuleConvertResponse";
 import { SecurityMonitoringRuleCreatePayload } from "../models/SecurityMonitoringRuleCreatePayload";
 import { SecurityMonitoringRuleResponse } from "../models/SecurityMonitoringRuleResponse";
+import { SecurityMonitoringRuleTestRequest } from "../models/SecurityMonitoringRuleTestRequest";
+import { SecurityMonitoringRuleTestResponse } from "../models/SecurityMonitoringRuleTestResponse";
 import { SecurityMonitoringRuleUpdatePayload } from "../models/SecurityMonitoringRuleUpdatePayload";
+import { SecurityMonitoringRuleValidatePayload } from "../models/SecurityMonitoringRuleValidatePayload";
 import { SecurityMonitoringSignal } from "../models/SecurityMonitoringSignal";
 import { SecurityMonitoringSignalAssigneeUpdateRequest } from "../models/SecurityMonitoringSignalAssigneeUpdateRequest";
 import { SecurityMonitoringSignalIncidentsUpdateRequest } from "../models/SecurityMonitoringSignalIncidentsUpdateRequest";
@@ -30,6 +35,8 @@ import { SecurityMonitoringSuppressionResponse } from "../models/SecurityMonitor
 import { SecurityMonitoringSuppressionsResponse } from "../models/SecurityMonitoringSuppressionsResponse";
 import { SecurityMonitoringSuppressionUpdateRequest } from "../models/SecurityMonitoringSuppressionUpdateRequest";
 export declare class SecurityMonitoringApiRequestFactory extends BaseAPIRequestFactory {
+    convertExistingSecurityMonitoringRule(ruleId: string, _options?: Configuration): Promise<RequestContext>;
+    convertSecurityMonitoringRuleFromJSONToTerraform(body: SecurityMonitoringRuleConvertPayload, _options?: Configuration): Promise<RequestContext>;
     createSecurityFilter(body: SecurityFilterCreateRequest, _options?: Configuration): Promise<RequestContext>;
     createSecurityMonitoringRule(body: SecurityMonitoringRuleCreatePayload, _options?: Configuration): Promise<RequestContext>;
     createSecurityMonitoringSuppression(body: SecurityMonitoringSuppressionCreateRequest, _options?: Configuration): Promise<RequestContext>;
@@ -51,12 +58,30 @@ export declare class SecurityMonitoringApiRequestFactory extends BaseAPIRequestF
     listSecurityMonitoringSuppressions(_options?: Configuration): Promise<RequestContext>;
     muteFindings(body: BulkMuteFindingsRequest, _options?: Configuration): Promise<RequestContext>;
     searchSecurityMonitoringSignals(body?: SecurityMonitoringSignalListRequest, _options?: Configuration): Promise<RequestContext>;
+    testExistingSecurityMonitoringRule(ruleId: string, body: SecurityMonitoringRuleTestRequest, _options?: Configuration): Promise<RequestContext>;
+    testSecurityMonitoringRule(body: SecurityMonitoringRuleTestRequest, _options?: Configuration): Promise<RequestContext>;
     updateSecurityFilter(securityFilterId: string, body: SecurityFilterUpdateRequest, _options?: Configuration): Promise<RequestContext>;
     updateSecurityMonitoringRule(ruleId: string, body: SecurityMonitoringRuleUpdatePayload, _options?: Configuration): Promise<RequestContext>;
     updateSecurityMonitoringSuppression(suppressionId: string, body: SecurityMonitoringSuppressionUpdateRequest, _options?: Configuration): Promise<RequestContext>;
-    validateSecurityMonitoringRule(body: SecurityMonitoringRuleCreatePayload, _options?: Configuration): Promise<RequestContext>;
+    validateSecurityMonitoringRule(body: SecurityMonitoringRuleValidatePayload, _options?: Configuration): Promise<RequestContext>;
 }
 export declare class SecurityMonitoringApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to convertExistingSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertExistingSecurityMonitoringRule(response: ResponseContext): Promise<SecurityMonitoringRuleConvertResponse>;
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to convertSecurityMonitoringRuleFromJSONToTerraform
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertSecurityMonitoringRuleFromJSONToTerraform(response: ResponseContext): Promise<SecurityMonitoringRuleConvertResponse>;
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -225,6 +250,22 @@ export declare class SecurityMonitoringApiResponseProcessor {
      * @throws ApiException if the response code was not in [200, 299]
      */
     searchSecurityMonitoringSignals(response: ResponseContext): Promise<SecurityMonitoringSignalsListResponse>;
+    /**
+     * 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 testExistingSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    testExistingSecurityMonitoringRule(response: ResponseContext): Promise<SecurityMonitoringRuleTestResponse>;
+    /**
+     * 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 testSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    testSecurityMonitoringRule(response: ResponseContext): Promise<SecurityMonitoringRuleTestResponse>;
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -258,6 +299,19 @@ export declare class SecurityMonitoringApiResponseProcessor {
      */
     validateSecurityMonitoringRule(response: ResponseContext): Promise<void>;
 }
+export interface SecurityMonitoringApiConvertExistingSecurityMonitoringRuleRequest {
+    /**
+     * The ID of the rule.
+     * @type string
+     */
+    ruleId: string;
+}
+export interface SecurityMonitoringApiConvertSecurityMonitoringRuleFromJSONToTerraformRequest {
+    /**
+     * @type SecurityMonitoringRuleConvertPayload
+     */
+    body: SecurityMonitoringRuleConvertPayload;
+}
 export interface SecurityMonitoringApiCreateSecurityFilterRequest {
     /**
      * The definition of the new security filter.
@@ -503,6 +557,23 @@ export interface SecurityMonitoringApiSearchSecurityMonitoringSignalsRequest {
      */
     body?: SecurityMonitoringSignalListRequest;
 }
+export interface SecurityMonitoringApiTestExistingSecurityMonitoringRuleRequest {
+    /**
+     * The ID of the rule.
+     * @type string
+     */
+    ruleId: string;
+    /**
+     * @type SecurityMonitoringRuleTestRequest
+     */
+    body: SecurityMonitoringRuleTestRequest;
+}
+export interface SecurityMonitoringApiTestSecurityMonitoringRuleRequest {
+    /**
+     * @type SecurityMonitoringRuleTestRequest
+     */
+    body: SecurityMonitoringRuleTestRequest;
+}
 export interface SecurityMonitoringApiUpdateSecurityFilterRequest {
     /**
      * The ID of the security filter.
@@ -540,15 +611,27 @@ export interface SecurityMonitoringApiUpdateSecurityMonitoringSuppressionRequest
 }
 export interface SecurityMonitoringApiValidateSecurityMonitoringRuleRequest {
     /**
-     * @type SecurityMonitoringRuleCreatePayload
+     * @type SecurityMonitoringRuleValidatePayload
      */
-    body: SecurityMonitoringRuleCreatePayload;
+    body: SecurityMonitoringRuleValidatePayload;
 }
 export declare class SecurityMonitoringApi {
     private requestFactory;
     private responseProcessor;
     private configuration;
     constructor(configuration: Configuration, requestFactory?: SecurityMonitoringApiRequestFactory, responseProcessor?: SecurityMonitoringApiResponseProcessor);
+    /**
+     * Convert an existing rule from JSON to Terraform for datadog provider
+     * resource datadog_security_monitoring_rule.
+     * @param param The request object
+     */
+    convertExistingSecurityMonitoringRule(param: SecurityMonitoringApiConvertExistingSecurityMonitoringRuleRequest, options?: Configuration): Promise<SecurityMonitoringRuleConvertResponse>;
+    /**
+     * Convert a rule that doesn't (yet) exist from JSON to Terraform for datadog provider
+     * resource datadog_security_monitoring_rule.
+     * @param param The request object
+     */
+    convertSecurityMonitoringRuleFromJSONToTerraform(param: SecurityMonitoringApiConvertSecurityMonitoringRuleFromJSONToTerraformRequest, options?: Configuration): Promise<SecurityMonitoringRuleConvertResponse>;
     /**
      * Create a security filter.
      *
@@ -705,6 +788,16 @@ export declare class SecurityMonitoringApi {
      * Provide a paginated version of searchSecurityMonitoringSignals returning a generator with all the items.
      */
     searchSecurityMonitoringSignalsWithPagination(param?: SecurityMonitoringApiSearchSecurityMonitoringSignalsRequest, options?: Configuration): AsyncGenerator<SecurityMonitoringSignal>;
+    /**
+     * Test an existing rule.
+     * @param param The request object
+     */
+    testExistingSecurityMonitoringRule(param: SecurityMonitoringApiTestExistingSecurityMonitoringRuleRequest, options?: Configuration): Promise<SecurityMonitoringRuleTestResponse>;
+    /**
+     * Test a rule.
+     * @param param The request object
+     */
+    testSecurityMonitoringRule(param: SecurityMonitoringApiTestSecurityMonitoringRuleRequest, options?: Configuration): Promise<SecurityMonitoringRuleTestResponse>;
     /**
      * Update a specific security filter.
      * Returns the security filter object when the request is successful.
@@ -714,7 +807,8 @@ export declare class SecurityMonitoringApi {
     /**
      * Update an existing rule. When updating `cases`, `queries` or `options`, the whole field
      * must be included. For example, when modifying a query all queries must be included.
-     * Default rules can only be updated to be enabled and to change notifications.
+     * Default rules can only be updated to be enabled, to change notifications, or to update
+     * the tags (default tags cannot be removed).
      * @param param The request object
      */
     updateSecurityMonitoringRule(param: SecurityMonitoringApiUpdateSecurityMonitoringRuleRequest, options?: Configuration): Promise<SecurityMonitoringRuleResponse>;

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

@@ -31,6 +31,61 @@ const exception_1 = require("../../datadog-api-client-common/exception");
 const SecurityMonitoringSignalListRequest_1 = require("../models/SecurityMonitoringSignalListRequest");
 const SecurityMonitoringSignalListRequestPage_1 = require("../models/SecurityMonitoringSignalListRequestPage");
 class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactory {
+    convertExistingSecurityMonitoringRule(ruleId, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'ruleId' is not null or undefined
+            if (ruleId === null || ruleId === undefined) {
+                throw new baseapi_1.RequiredError("ruleId", "convertExistingSecurityMonitoringRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security_monitoring/rules/{rule_id}/convert".replace("{rule_id}", encodeURIComponent(String(ruleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.convertExistingSecurityMonitoringRule")
+                .makeRequestContext(localVarPath, http_1.HttpMethod.GET);
+            requestContext.setHeaderParam("Accept", "application/json");
+            requestContext.setHttpConfig(_config.httpConfig);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    convertSecurityMonitoringRuleFromJSONToTerraform(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "convertSecurityMonitoringRuleFromJSONToTerraform");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security_monitoring/rules/convert";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.convertSecurityMonitoringRuleFromJSONToTerraform")
+                .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, "SecurityMonitoringRuleConvertPayload", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     createSecurityFilter(body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -654,6 +709,72 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
             return requestContext;
         });
     }
+    testExistingSecurityMonitoringRule(ruleId, body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'ruleId' is not null or undefined
+            if (ruleId === null || ruleId === undefined) {
+                throw new baseapi_1.RequiredError("ruleId", "testExistingSecurityMonitoringRule");
+            }
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "testExistingSecurityMonitoringRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security_monitoring/rules/{rule_id}/test".replace("{rule_id}", encodeURIComponent(String(ruleId)));
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.testExistingSecurityMonitoringRule")
+                .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, "SecurityMonitoringRuleTestRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
+    testSecurityMonitoringRule(body, _options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _config = _options || this.configuration;
+            // verify required parameter 'body' is not null or undefined
+            if (body === null || body === undefined) {
+                throw new baseapi_1.RequiredError("body", "testSecurityMonitoringRule");
+            }
+            // Path Params
+            const localVarPath = "/api/v2/security_monitoring/rules/test";
+            // Make Request Context
+            const requestContext = _config
+                .getServer("v2.SecurityMonitoringApi.testSecurityMonitoringRule")
+                .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, "SecurityMonitoringRuleTestRequest", ""), contentType);
+            requestContext.setBody(serializedBody);
+            // Apply auth methods
+            (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
+                "AuthZ",
+                "apiKeyAuth",
+                "appKeyAuth",
+            ]);
+            return requestContext;
+        });
+    }
     updateSecurityFilter(securityFilterId, body, _options) {
         return __awaiter(this, void 0, void 0, function* () {
             const _config = _options || this.configuration;
@@ -779,7 +900,7 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
                 "application/json",
             ]);
             requestContext.setHeaderParam("Content-Type", contentType);
-            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "SecurityMonitoringRuleCreatePayload", ""), contentType);
+            const serializedBody = ObjectSerializer_1.ObjectSerializer.stringify(ObjectSerializer_1.ObjectSerializer.serialize(body, "SecurityMonitoringRuleValidatePayload", ""), contentType);
             requestContext.setBody(serializedBody);
             // Apply auth methods
             (0, configuration_1.applySecurityAuthentication)(_config, requestContext, [
@@ -793,6 +914,83 @@ class SecurityMonitoringApiRequestFactory extends baseapi_1.BaseAPIRequestFactor
 }
 exports.SecurityMonitoringApiRequestFactory = SecurityMonitoringApiRequestFactory;
 class SecurityMonitoringApiResponseProcessor {
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to convertExistingSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertExistingSecurityMonitoringRule(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleConvertResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleConvertResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to convertSecurityMonitoringRuleFromJSONToTerraform
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    convertSecurityMonitoringRuleFromJSONToTerraform(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const contentType = ObjectSerializer_1.ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
+            if (response.httpStatusCode === 200) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleConvertResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleConvertResponse", "");
+                return body;
+            }
+            const body = (yield response.body.text()) || "";
+            throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
+        });
+    }
     /**
      * Unwraps the actual response sent by the server from the response context and deserializes the response content
      * to the expected objects
@@ -1566,6 +1764,84 @@ class SecurityMonitoringApiResponseProcessor {
             throw new exception_1.ApiException(response.httpStatusCode, 'Unknown API Status Code!\nBody: "' + body + '"');
         });
     }
+    /**
+     * Unwraps the actual response sent by the server from the response context and deserializes the response content
+     * to the expected objects
+     *
+     * @params response Response returned by the server for a request to testExistingSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    testExistingSecurityMonitoringRule(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), "SecurityMonitoringRuleTestResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleTestResponse", "");
+                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 testSecurityMonitoringRule
+     * @throws ApiException if the response code was not in [200, 299]
+     */
+    testSecurityMonitoringRule(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), "SecurityMonitoringRuleTestResponse");
+                return body;
+            }
+            if (response.httpStatusCode === 400 ||
+                response.httpStatusCode === 401 ||
+                response.httpStatusCode === 403 ||
+                response.httpStatusCode === 404 ||
+                response.httpStatusCode === 429) {
+                const bodyText = ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType);
+                let body;
+                try {
+                    body = ObjectSerializer_1.ObjectSerializer.deserialize(bodyText, "APIErrorResponse");
+                }
+                catch (error) {
+                    logger_1.logger.debug(`Got error deserializing error: ${error}`);
+                    throw new exception_1.ApiException(response.httpStatusCode, bodyText);
+                }
+                throw new exception_1.ApiException(response.httpStatusCode, body);
+            }
+            // Work around for missing responses in specification, e.g. for petstore.yaml
+            if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+                const body = ObjectSerializer_1.ObjectSerializer.deserialize(ObjectSerializer_1.ObjectSerializer.parse(yield response.body.text(), contentType), "SecurityMonitoringRuleTestResponse", "");
+                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
@@ -1729,6 +2005,36 @@ class SecurityMonitoringApi {
         this.responseProcessor =
             responseProcessor || new SecurityMonitoringApiResponseProcessor();
     }
+    /**
+     * Convert an existing rule from JSON to Terraform for datadog provider
+     * resource datadog_security_monitoring_rule.
+     * @param param The request object
+     */
+    convertExistingSecurityMonitoringRule(param, options) {
+        const requestContextPromise = this.requestFactory.convertExistingSecurityMonitoringRule(param.ruleId, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.convertExistingSecurityMonitoringRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Convert a rule that doesn't (yet) exist from JSON to Terraform for datadog provider
+     * resource datadog_security_monitoring_rule.
+     * @param param The request object
+     */
+    convertSecurityMonitoringRuleFromJSONToTerraform(param, options) {
+        const requestContextPromise = this.requestFactory.convertSecurityMonitoringRuleFromJSONToTerraform(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.convertSecurityMonitoringRuleFromJSONToTerraform(responseContext);
+            });
+        });
+    }
     /**
      * Create a security filter.
      *
@@ -2191,6 +2497,34 @@ class SecurityMonitoringApi {
             }
         });
     }
+    /**
+     * Test an existing rule.
+     * @param param The request object
+     */
+    testExistingSecurityMonitoringRule(param, options) {
+        const requestContextPromise = this.requestFactory.testExistingSecurityMonitoringRule(param.ruleId, param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.testExistingSecurityMonitoringRule(responseContext);
+            });
+        });
+    }
+    /**
+     * Test a rule.
+     * @param param The request object
+     */
+    testSecurityMonitoringRule(param, options) {
+        const requestContextPromise = this.requestFactory.testSecurityMonitoringRule(param.body, options);
+        return requestContextPromise.then((requestContext) => {
+            return this.configuration.httpApi
+                .send(requestContext)
+                .then((responseContext) => {
+                return this.responseProcessor.testSecurityMonitoringRule(responseContext);
+            });
+        });
+    }
     /**
      * Update a specific security filter.
      * Returns the security filter object when the request is successful.
@@ -2209,7 +2543,8 @@ class SecurityMonitoringApi {
     /**
      * Update an existing rule. When updating `cases`, `queries` or `options`, the whole field
      * must be included. For example, when modifying a query all queries must be included.
-     * Default rules can only be updated to be enabled and to change notifications.
+     * Default rules can only be updated to be enabled, to change notifications, or to update
+     * the tags (default tags cannot be removed).
      * @param param The request object
      */
     updateSecurityMonitoringRule(param, options) {