Document Cloud SIEM Growth and Content owned endpoints

examples/v2_security-monitoring_BulkCreateSampleLogGenerationSubscriptions.rs

@@ -0,0 +1,31 @@
+// Bulk subscribe to sample log generation returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::SampleLogGenerationBulkSubscriptionAttributes;
+use datadog_api_client::datadogV2::model::SampleLogGenerationBulkSubscriptionData;
+use datadog_api_client::datadogV2::model::SampleLogGenerationBulkSubscriptionRequest;
+use datadog_api_client::datadogV2::model::SampleLogGenerationBulkSubscriptionRequestType;
+use datadog_api_client::datadogV2::model::SampleLogGenerationDuration;
+
+#[tokio::main]
+async fn main() {
+    let body = SampleLogGenerationBulkSubscriptionRequest::new(
+        SampleLogGenerationBulkSubscriptionData::new(
+            SampleLogGenerationBulkSubscriptionAttributes::new(vec!["aws-cloudtrail".to_string()])
+                .duration(SampleLogGenerationDuration::THREE_DAYS),
+            SampleLogGenerationBulkSubscriptionRequestType::BULK_SUBSCRIPTION_REQUESTS,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.BulkCreateSampleLogGenerationSubscriptions", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .bulk_create_sample_log_generation_subscriptions(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_CreateSampleLogGenerationSubscription.rs

@@ -0,0 +1,28 @@
+// Subscribe to sample log generation returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::SampleLogGenerationDuration;
+use datadog_api_client::datadogV2::model::SampleLogGenerationSubscriptionCreateAttributes;
+use datadog_api_client::datadogV2::model::SampleLogGenerationSubscriptionCreateData;
+use datadog_api_client::datadogV2::model::SampleLogGenerationSubscriptionCreateRequest;
+use datadog_api_client::datadogV2::model::SampleLogGenerationSubscriptionRequestType;
+
+#[tokio::main]
+async fn main() {
+    let body = SampleLogGenerationSubscriptionCreateRequest::new(
+        SampleLogGenerationSubscriptionCreateData::new(
+            SampleLogGenerationSubscriptionCreateAttributes::new("aws-cloudtrail".to_string())
+                .duration(SampleLogGenerationDuration::THREE_DAYS),
+            SampleLogGenerationSubscriptionRequestType::SUBSCRIPTION_REQUESTS,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateSampleLogGenerationSubscription", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api.create_sample_log_generation_subscription(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_CreateSecurityMonitoringIntegrationConfig.rs

@@ -0,0 +1,41 @@
+// Create an entity context sync configuration returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigCreateAttributes;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigCreateData;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigCreateRequest;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigResourceType;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationType;
+use serde_json::Value;
+use std::collections::BTreeMap;
+
+#[tokio::main]
+async fn main() {
+    let body = SecurityMonitoringIntegrationConfigCreateRequest::new(
+        SecurityMonitoringIntegrationConfigCreateData::new(
+            SecurityMonitoringIntegrationConfigCreateAttributes::new(
+                "siem-test.com".to_string(),
+                SecurityMonitoringIntegrationType::GOOGLE_WORKSPACE,
+                "My GWS Integration".to_string(),
+                BTreeMap::from([("admin_email".to_string(), Value::from("test@example.com"))]),
+            )
+            .settings(BTreeMap::from([(
+                "setting1".to_string(),
+                Value::from("value1"),
+            )])),
+            SecurityMonitoringIntegrationConfigResourceType::INTEGRATION_CONFIG,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.CreateSecurityMonitoringIntegrationConfig", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .create_security_monitoring_integration_config(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_DeleteSampleLogGenerationSubscription.rs

@@ -0,0 +1,18 @@
+// Unsubscribe from sample log generation returns "OK" response
+use datadog_api_client::datadog;
+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.DeleteSampleLogGenerationSubscription", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .delete_sample_log_generation_subscription("content_pack_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_DeleteSecurityMonitoringIntegrationConfig.rs

@@ -0,0 +1,19 @@
+// Delete an entity context sync configuration returns "OK" response
+use datadog_api_client::datadog;
+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.DeleteSecurityMonitoringIntegrationConfig", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .delete_security_monitoring_integration_config("integration_config_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetEntityContext.rs

@@ -0,0 +1,19 @@
+// Get entity context returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::GetEntityContextOptionalParams;
+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.GetEntityContext", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_entity_context(GetEntityContextOptionalParams::default())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetSecurityMonitoringIntegrationConfig.rs

@@ -0,0 +1,18 @@
+// Get an entity context sync configuration returns "OK" response
+use datadog_api_client::datadog;
+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.GetSecurityMonitoringIntegrationConfig", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_security_monitoring_integration_config("integration_config_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetSignalEntities.rs

@@ -0,0 +1,22 @@
+// Get entities related to a signal returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::GetSignalEntitiesOptionalParams;
+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.GetSignalEntities", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_signal_entities(
+            "signal_id".to_string(),
+            GetSignalEntitiesOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListSampleLogGenerationSubscriptions.rs

@@ -0,0 +1,21 @@
+// Get sample log generation subscriptions returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::ListSampleLogGenerationSubscriptionsOptionalParams;
+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.ListSampleLogGenerationSubscriptions", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .list_sample_log_generation_subscriptions(
+            ListSampleLogGenerationSubscriptionsOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListSecurityFilterVersions.rs

@@ -0,0 +1,15 @@
+// Get the version history of security filters returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api.list_security_filter_versions().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListSecurityMonitoringIntegrationConfigs.rs

@@ -0,0 +1,22 @@
+// List entity context sync configurations returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::ListSecurityMonitoringIntegrationConfigsOptionalParams;
+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.ListSecurityMonitoringIntegrationConfigs", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .list_security_monitoring_integration_configs(
+            ListSecurityMonitoringIntegrationConfigsOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_UpdateSecurityMonitoringIntegrationConfig.rs

@@ -0,0 +1,44 @@
+// Update an entity context sync configuration returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigResourceType;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigUpdateAttributes;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigUpdateData;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigUpdateRequest;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationType;
+use serde_json::Value;
+use std::collections::BTreeMap;
+
+#[tokio::main]
+async fn main() {
+    let body = SecurityMonitoringIntegrationConfigUpdateRequest::new(
+        SecurityMonitoringIntegrationConfigUpdateData::new(
+            SecurityMonitoringIntegrationConfigUpdateAttributes::new()
+                .domain("siem-test.com".to_string())
+                .enabled(true)
+                .integration_type(SecurityMonitoringIntegrationType::GOOGLE_WORKSPACE)
+                .name("My GWS Integration (renamed)".to_string())
+                .secrets(BTreeMap::from([(
+                    "admin_email".to_string(),
+                    Value::from("test@example.com"),
+                )]))
+                .settings(BTreeMap::from([(
+                    "setting1".to_string(),
+                    Value::from("value1"),
+                )])),
+            SecurityMonitoringIntegrationConfigResourceType::INTEGRATION_CONFIG,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration
+        .set_unstable_operation_enabled("v2.UpdateSecurityMonitoringIntegrationConfig", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .update_security_monitoring_integration_config("integration_config_id".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ValidateSecurityMonitoringIntegrationConfig.rs

@@ -0,0 +1,19 @@
+// Validate an entity context sync configuration returns "OK" response
+use datadog_api_client::datadog;
+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.ValidateSecurityMonitoringIntegrationConfig", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .validate_security_monitoring_integration_config("integration_config_id".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ValidateSecurityMonitoringIntegrationCredentials.rs

@@ -0,0 +1,38 @@
+// Validate entity context sync credentials returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationConfigResourceType;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationCredentialsValidateAttributes;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationCredentialsValidateData;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationCredentialsValidateRequest;
+use datadog_api_client::datadogV2::model::SecurityMonitoringIntegrationType;
+use serde_json::Value;
+use std::collections::BTreeMap;
+
+#[tokio::main]
+async fn main() {
+    let body = SecurityMonitoringIntegrationCredentialsValidateRequest::new(
+        SecurityMonitoringIntegrationCredentialsValidateData::new(
+            SecurityMonitoringIntegrationCredentialsValidateAttributes::new(
+                "siem-test.com".to_string(),
+                SecurityMonitoringIntegrationType::GOOGLE_WORKSPACE,
+                BTreeMap::from([("admin_email".to_string(), Value::from("test@example.com"))]),
+            ),
+            SecurityMonitoringIntegrationConfigResourceType::INTEGRATION_CONFIG,
+        ),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled(
+        "v2.ValidateSecurityMonitoringIntegrationCredentials",
+        true,
+    );
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .validate_security_monitoring_integration_credentials(body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}