Regenerate client from commit ad64ebe of spec repo

Author: ci.datadog-api-spec

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,27 @@
+// Create Custom Rule returns "Successfully created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+use datadog_api_client::datadogV2::model::CustomRuleDataType;
+use datadog_api_client::datadogV2::model::CustomRuleRequest;
+use datadog_api_client::datadogV2::model::CustomRuleRequestData;
+use datadog_api_client::datadogV2::model::CustomRuleRequestDataAttributes;
+
+#[tokio::main]
+async fn main() {
+    let body = CustomRuleRequest::new().data(
+        CustomRuleRequestData::new()
+            .attributes(CustomRuleRequestDataAttributes::new())
+            .type_(CustomRuleDataType::CUSTOM_RULE),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateCustomRule", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .create_custom_rule("ruleset_name".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_CreateCustomRule.rs

@@ -0,0 +1,57 @@
+// Create Custom Rule Revision returns "Successfully created" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+use datadog_api_client::datadogV2::model::Argument;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionAttributesCategory;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionAttributesSeverity;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionDataType;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionInputAttributes;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionRequest;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionRequestData;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionTest;
+use datadog_api_client::datadogV2::model::Language;
+
+#[tokio::main]
+async fn main() {
+    let body = CustomRuleRevisionRequest::new().data(
+        CustomRuleRevisionRequestData::new()
+            .attributes(CustomRuleRevisionInputAttributes::new(
+                vec![Argument::new(
+                    "YXJndW1lbnQgZGVzY3JpcHRpb24=".to_string(),
+                    "YXJndW1lbnRfbmFtZQ==".to_string(),
+                )],
+                CustomRuleRevisionAttributesCategory::SECURITY,
+                "Y29uZHVjdG9yOgogICAgLSBkZXBsb3lfb25seTogdHJ1ZQ==".to_string(),
+                "Initial revision".to_string(),
+                Some("CVE-2024-1234".to_string()),
+                Some("CWE-79".to_string()),
+                "bG9uZyBkZXNjcmlwdGlvbg==".to_string(),
+                Some("https://docs.example.com/rules/my-rule".to_string()),
+                false,
+                false,
+                Language::PYTHON,
+                CustomRuleRevisionAttributesSeverity::ERROR,
+                "c2hvcnQgZGVzY3JpcHRpb24=".to_string(),
+                false,
+                vec!["security".to_string(), "custom".to_string()],
+                vec![CustomRuleRevisionTest::new(
+                    1,
+                    "Y29uZHVjdG9yOgogICAgLSBkZXBsb3lfb25seTogdHJ1ZQ==".to_string(),
+                    "test.yaml".to_string(),
+                )],
+                "Y29uZHVjdG9yOgogICAgLSBkZXBsb3lfb25seTogdHJ1ZQ==".to_string(),
+            ))
+            .type_(CustomRuleRevisionDataType::CUSTOM_RULE_REVISION),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateCustomRuleRevision", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .create_custom_rule_revision("ruleset_name".to_string(), "rule_name".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_CreateCustomRuleRevision.rs

@@ -0,0 +1,18 @@
+// Delete Custom Rule returns "Successfully deleted" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteCustomRule", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .delete_custom_rule("ruleset_name".to_string(), "rule_name".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_DeleteCustomRule.rs

@@ -0,0 +1,16 @@
+// Delete Custom Ruleset returns "Successfully deleted" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.DeleteCustomRuleset", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api.delete_custom_ruleset("ruleset_name".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_DeleteCustomRuleset.rs

@@ -0,0 +1,23 @@
+// List Custom Rule Revisions returns "Successful response" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::ListCustomRuleRevisionsOptionalParams;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ListCustomRuleRevisions", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .list_custom_rule_revisions(
+            "ruleset_name".to_string(),
+            "rule_name".to_string(),
+            ListCustomRuleRevisionsOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_ListCustomRuleRevisions.rs

@@ -0,0 +1,27 @@
+// Revert Custom Rule Revision returns "Successfully reverted" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+use datadog_api_client::datadogV2::model::RevertCustomRuleRevisionDataType;
+use datadog_api_client::datadogV2::model::RevertCustomRuleRevisionRequest;
+use datadog_api_client::datadogV2::model::RevertCustomRuleRevisionRequestData;
+use datadog_api_client::datadogV2::model::RevertCustomRuleRevisionRequestDataAttributes;
+
+#[tokio::main]
+async fn main() {
+    let body = RevertCustomRuleRevisionRequest::new().data(
+        RevertCustomRuleRevisionRequestData::new()
+            .attributes(RevertCustomRuleRevisionRequestDataAttributes::new())
+            .type_(RevertCustomRuleRevisionDataType::REVERT_CUSTOM_RULE_REVISION_REQUEST),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.RevertCustomRuleRevision", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .revert_custom_rule_revision("ruleset_name".to_string(), "rule_name".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_RevertCustomRuleRevision.rs

@@ -0,0 +1,18 @@
+// Show Custom Rule returns "Successful response" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ShowCustomRule", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .show_custom_rule("ruleset_name".to_string(), "rule_name".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_ShowCustomRule.rs

@@ -0,0 +1,22 @@
+// Show Custom Rule Revision returns "Successful response" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ShowCustomRuleRevision", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .show_custom_rule_revision(
+            "ruleset_name".to_string(),
+            "rule_name".to_string(),
+            "id".to_string(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_ShowCustomRuleRevision.rs

@@ -0,0 +1,16 @@
+// Show Custom Ruleset returns "Successful response" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_static_analysis::StaticAnalysisAPI;
+
+#[tokio::main]
+async fn main() {
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.ShowCustomRuleset", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api.show_custom_ruleset("ruleset_name".to_string()).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}