Add public API for security findings automation rules

examples/v2_security-monitoring_CreateSecurityFindingsAutomationDueDateRule.rs

@@ -0,0 +1,42 @@
+// Create a due date rule returns "Successfully created the due date rule" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::AutomationRuleScope;
+use datadog_api_client::datadogV2::model::DueDateFrom;
+use datadog_api_client::datadogV2::model::DueDatePerSeverityItem;
+use datadog_api_client::datadogV2::model::DueDateRuleAction;
+use datadog_api_client::datadogV2::model::DueDateRuleAttributesCreate;
+use datadog_api_client::datadogV2::model::DueDateRuleCreateRequest;
+use datadog_api_client::datadogV2::model::DueDateRuleDataCreate;
+use datadog_api_client::datadogV2::model::DueDateRuleType;
+use datadog_api_client::datadogV2::model::DueDateSeverity;
+use datadog_api_client::datadogV2::model::SecurityFindingType;
+
+#[tokio::main]
+async fn main() {
+    let body = DueDateRuleCreateRequest::new(DueDateRuleDataCreate::new(
+        DueDateRuleAttributesCreate::new(
+            DueDateRuleAction::new(
+                vec![DueDatePerSeverityItem::new(7, DueDateSeverity::CRITICAL)],
+                DueDateFrom::FIRST_SEEN,
+            ),
+            "Example-Security-Monitoring".to_string(),
+            AutomationRuleScope::new(vec![SecurityFindingType::MISCONFIGURATION])
+                .query("env:staging".to_string()),
+        )
+        .enabled(true),
+        DueDateRuleType::DUE_DATE_RULES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.CreateSecurityFindingsAutomationDueDateRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .create_security_findings_automation_due_date_rule(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_CreateSecurityFindingsAutomationMuteRule.rs

@@ -0,0 +1,37 @@
+// Create a mute rule returns "Successfully created the mute rule" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::AutomationRuleScope;
+use datadog_api_client::datadogV2::model::MuteReason;
+use datadog_api_client::datadogV2::model::MuteRuleAction;
+use datadog_api_client::datadogV2::model::MuteRuleAttributesCreate;
+use datadog_api_client::datadogV2::model::MuteRuleCreateRequest;
+use datadog_api_client::datadogV2::model::MuteRuleDataCreate;
+use datadog_api_client::datadogV2::model::MuteRuleType;
+use datadog_api_client::datadogV2::model::SecurityFindingType;
+
+#[tokio::main]
+async fn main() {
+    let body = MuteRuleCreateRequest::new(MuteRuleDataCreate::new(
+        MuteRuleAttributesCreate::new(
+            MuteRuleAction::new(MuteReason::RISK_ACCEPTED),
+            "Example-Security-Monitoring".to_string(),
+            AutomationRuleScope::new(vec![SecurityFindingType::MISCONFIGURATION])
+                .query("env:staging".to_string()),
+        )
+        .enabled(true),
+        MuteRuleType::MUTE_RULES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.CreateSecurityFindingsAutomationMuteRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .create_security_findings_automation_mute_rule(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_CreateSecurityFindingsAutomationTicketCreationRule.rs

@@ -0,0 +1,45 @@
+// Create a ticket creation rule returns "Successfully created the ticket creation
+// rule" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::AutomationRuleScope;
+use datadog_api_client::datadogV2::model::SecurityFindingType;
+use datadog_api_client::datadogV2::model::TicketCreationRuleAction;
+use datadog_api_client::datadogV2::model::TicketCreationRuleAttributesCreate;
+use datadog_api_client::datadogV2::model::TicketCreationRuleCreateRequest;
+use datadog_api_client::datadogV2::model::TicketCreationRuleDataCreate;
+use datadog_api_client::datadogV2::model::TicketCreationRuleType;
+use datadog_api_client::datadogV2::model::TicketCreationTarget;
+use uuid::Uuid;
+
+#[tokio::main]
+async fn main() {
+    let body = TicketCreationRuleCreateRequest::new(TicketCreationRuleDataCreate::new(
+        TicketCreationRuleAttributesCreate::new(
+            TicketCreationRuleAction::new(
+                10,
+                Uuid::parse_str("11111111-1111-1111-1111-111111111111").expect("invalid UUID"),
+                TicketCreationTarget::JIRA,
+            ),
+            "Example-Security-Monitoring".to_string(),
+            AutomationRuleScope::new(vec![SecurityFindingType::MISCONFIGURATION])
+                .query("env:staging".to_string()),
+        )
+        .enabled(true),
+        TicketCreationRuleType::TICKET_CREATION_RULES,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled(
+        "v2.CreateSecurityFindingsAutomationTicketCreationRule",
+        true,
+    );
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .create_security_findings_automation_ticket_creation_rule(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_DeleteSecurityFindingsAutomationDueDateRule.rs

@@ -0,0 +1,23 @@
+// Delete a due date rule returns "Rule successfully deleted." response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_due_date_rule" in the system
+    let valid_due_date_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_DUE_DATE_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.DeleteSecurityFindingsAutomationDueDateRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .delete_security_findings_automation_due_date_rule(valid_due_date_rule_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_DeleteSecurityFindingsAutomationMuteRule.rs

@@ -0,0 +1,23 @@
+// Delete a mute rule returns "Rule successfully deleted." response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_mute_rule" in the system
+    let valid_mute_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_MUTE_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.DeleteSecurityFindingsAutomationMuteRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .delete_security_findings_automation_mute_rule(valid_mute_rule_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_DeleteSecurityFindingsAutomationTicketCreationRule.rs

@@ -0,0 +1,27 @@
+// Delete a ticket creation rule returns "Rule successfully deleted." response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_ticket_creation_rule" in the system
+    let valid_ticket_creation_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_TICKET_CREATION_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled(
+        "v2.DeleteSecurityFindingsAutomationTicketCreationRule",
+        true,
+    );
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .delete_security_findings_automation_ticket_creation_rule(
+            valid_ticket_creation_rule_data_id.clone(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetSecurityFindingsAutomationDueDateRule.rs

@@ -0,0 +1,23 @@
+// Get a due date rule returns "Successfully retrieved the due date rule" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_due_date_rule" in the system
+    let valid_due_date_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_DUE_DATE_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.GetSecurityFindingsAutomationDueDateRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_security_findings_automation_due_date_rule(valid_due_date_rule_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetSecurityFindingsAutomationMuteRule.rs

@@ -0,0 +1,22 @@
+// Get a mute rule returns "Successfully retrieved the mute rule" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_mute_rule" in the system
+    let valid_mute_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_MUTE_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.GetSecurityFindingsAutomationMuteRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_security_findings_automation_mute_rule(valid_mute_rule_data_id.clone())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetSecurityFindingsAutomationTicketCreationRule.rs

@@ -0,0 +1,26 @@
+// Get a ticket creation rule returns "Successfully retrieved the ticket creation
+// rule" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_ticket_creation_rule" in the system
+    let valid_ticket_creation_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_TICKET_CREATION_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.GetSecurityFindingsAutomationTicketCreationRule", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_security_findings_automation_ticket_creation_rule(
+            valid_ticket_creation_rule_data_id.clone(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListSecurityFindingsAutomationDueDateRules.rs

@@ -0,0 +1,23 @@
+// Get all due date rules returns "Successfully retrieved the list of due date
+// rules" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::ListSecurityFindingsAutomationDueDateRulesOptionalParams;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.ListSecurityFindingsAutomationDueDateRules", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .list_security_findings_automation_due_date_rules(
+            ListSecurityFindingsAutomationDueDateRulesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListSecurityFindingsAutomationMuteRules.rs

@@ -0,0 +1,23 @@
+// Get all mute rules returns "Successfully retrieved the list of mute rules"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::ListSecurityFindingsAutomationMuteRulesOptionalParams;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.ListSecurityFindingsAutomationMuteRules", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .list_security_findings_automation_mute_rules(
+            ListSecurityFindingsAutomationMuteRulesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListSecurityFindingsAutomationTicketCreationRules.rs

@@ -0,0 +1,25 @@
+// Get all ticket creation rules returns "Successfully retrieved the list of
+// ticket creation rules" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::ListSecurityFindingsAutomationTicketCreationRulesOptionalParams;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled(
+        "v2.ListSecurityFindingsAutomationTicketCreationRules",
+        true,
+    );
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .list_security_findings_automation_ticket_creation_rules(
+            ListSecurityFindingsAutomationTicketCreationRulesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ReorderSecurityFindingsAutomationDueDateRules.rs

@@ -0,0 +1,31 @@
+// Reorder due date rules returns "Successfully reordered the due date rules"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::DueDateRuleReorderItem;
+use datadog_api_client::datadogV2::model::DueDateRuleReorderRequest;
+use datadog_api_client::datadogV2::model::DueDateRuleType;
+
+#[tokio::main]
+async fn main() {
+    // there is a valid "valid_due_date_rule" in the system
+    let valid_due_date_rule_data_id =
+        uuid::Uuid::parse_str(&std::env::var("VALID_DUE_DATE_RULE_DATA_ID").unwrap())
+            .expect("Invalid UUID");
+    let body = DueDateRuleReorderRequest::new(vec![DueDateRuleReorderItem::new(
+        valid_due_date_rule_data_id.clone(),
+        DueDateRuleType::DUE_DATE_RULES,
+    )]);
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.ReorderSecurityFindingsAutomationDueDateRules", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .reorder_security_findings_automation_due_date_rules(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}