Add OpenAPI specs for static-analysis-api missing endpoints (#1651)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,28 @@
+// Get AST for source code returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::GetAstRequest;
+use datadog_api_client::datadogV2::model::GetAstRequestData;
+use datadog_api_client::datadogV2::model::GetAstRequestDataAttributes;
+use datadog_api_client::datadogV2::model::GetAstRequestDataType;
+
+#[tokio::main]
+async fn main() {
+    let body = GetAstRequest::new(GetAstRequestData::new(
+        GetAstRequestDataAttributes::new(
+            "aW1wb3J0IHN5cw==".to_string(),
+            "utf-8".to_string(),
+            "python".to_string(),
+        ),
+        GetAstRequestDataType::GET_AST_REQUEST,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateStaticAnalysisAst", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api.create_static_analysis_ast(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_CreateStaticAnalysisAst.rs

@@ -0,0 +1,42 @@
+// Analyze code returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::SecurityMonitoringAPI;
+use datadog_api_client::datadogV2::model::AnalysisRequest;
+use datadog_api_client::datadogV2::model::AnalysisRequestData;
+use datadog_api_client::datadogV2::model::AnalysisRequestDataAttributes;
+use datadog_api_client::datadogV2::model::AnalysisRequestDataType;
+use datadog_api_client::datadogV2::model::AnalysisRequestRule;
+
+#[tokio::main]
+async fn main() {
+    let body = AnalysisRequest::new(AnalysisRequestData::new(
+        AnalysisRequestDataAttributes::new(
+            "aW1wb3J0IHN5cw==".to_string(),
+            "utf-8".to_string(),
+            "test.py".to_string(),
+            "python".to_string(),
+            vec![AnalysisRequestRule::new(
+                "BEST_PRACTICES".to_string(),
+                "abc123def456".to_string(),
+                "ZnVuY3Rpb24gdmlzaXQobm9kZSkge30=".to_string(),
+                "python-best-practices/no-exit".to_string(),
+                "python".to_string(),
+                "WARNING".to_string(),
+                "KGNhbGwgbmFtZTogKGF0dHJpYnV0ZSkpQHZhbA==".to_string(),
+                "TREE_SITTER_QUERY".to_string(),
+            )
+            .entity_checked(None)
+            .regex(None)],
+        ),
+        AnalysisRequestDataType::ANALYSIS_REQUEST,
+    ));
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateStaticAnalysisServerAnalysis", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api.create_static_analysis_server_analysis(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_CreateStaticAnalysisServerAnalysis.rs

@@ -0,0 +1,18 @@
+// Get default rulesets for a language 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.GetStaticAnalysisDefaultRulesets", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_static_analysis_default_rulesets("python".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetStaticAnalysisDefaultRulesets.rs

@@ -0,0 +1,18 @@
+// Get node types for a language 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.GetStaticAnalysisNodeTypes", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_static_analysis_node_types("python".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetStaticAnalysisNodeTypes.rs

@@ -0,0 +1,22 @@
+// Get a SAST ruleset returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_security_monitoring::GetStaticAnalysisRulesetOptionalParams;
+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.GetStaticAnalysisRuleset", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_static_analysis_ruleset(
+            "python-best-practices".to_string(),
+            GetStaticAnalysisRulesetOptionalParams::default(),
+        )
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetStaticAnalysisRuleset.rs

@@ -0,0 +1,19 @@
+// Get tree-sitter WASM file returns "BLOB with the content of the WASM file"
+// 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.GetStaticAnalysisTreeSitterWasm", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api
+        .get_static_analysis_tree_sitter_wasm("tree-sitter-python.wasm".to_string())
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_GetStaticAnalysisTreeSitterWasm.rs

@@ -0,0 +1,16 @@
+// List codegen rulesets 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.ListStaticAnalysisCodegenRulesets", true);
+    let api = SecurityMonitoringAPI::with_config(configuration);
+    let resp = api.list_static_analysis_codegen_rulesets().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_security-monitoring_ListStaticAnalysisCodegenRulesets.rs

@@ -0,0 +1,28 @@
+// Create an AI 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::AiCustomRuleDataType;
+use datadog_api_client::datadogV2::model::AiCustomRuleRequest;
+use datadog_api_client::datadogV2::model::AiCustomRuleRequestAttributes;
+use datadog_api_client::datadogV2::model::AiCustomRuleRequestData;
+
+#[tokio::main]
+async fn main() {
+    let body = AiCustomRuleRequest::new().data(
+        AiCustomRuleRequestData::new()
+            .attributes(AiCustomRuleRequestAttributes::new().name("my-ai-rule".to_string()))
+            .id("my-ai-rule".to_string())
+            .type_(AiCustomRuleDataType::AI_RULE),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateAiCustomRule", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .create_ai_custom_rule("my-ai-ruleset".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

examples/v2_static-analysis_CreateAiCustomRule.rs

@@ -0,0 +1,46 @@
+// Create an AI 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::AiCustomRuleRevisionDataType;
+use datadog_api_client::datadogV2::model::AiCustomRuleRevisionExecutionMode;
+use datadog_api_client::datadogV2::model::AiCustomRuleRevisionRequest;
+use datadog_api_client::datadogV2::model::AiCustomRuleRevisionRequestAttributes;
+use datadog_api_client::datadogV2::model::AiCustomRuleRevisionRequestData;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionAttributesCategory;
+use datadog_api_client::datadogV2::model::CustomRuleRevisionAttributesSeverity;
+
+#[tokio::main]
+async fn main() {
+    let body = AiCustomRuleRevisionRequest::new().data(
+        AiCustomRuleRevisionRequestData::new()
+            .attributes(
+                AiCustomRuleRevisionRequestAttributes::new(
+                    CustomRuleRevisionAttributesCategory::SECURITY,
+                    "Content".to_string(),
+                    "Ruleset description".to_string(),
+                    vec![],
+                    AiCustomRuleRevisionExecutionMode::AUTO,
+                    vec!["**/*.py".to_string()],
+                    false,
+                    false,
+                    CustomRuleRevisionAttributesSeverity::ERROR,
+                    "Ruleset short description".to_string(),
+                )
+                .cwe(Some("79".to_string()))
+                .version_id(1),
+            )
+            .id("revision-abc-123".to_string())
+            .type_(AiCustomRuleRevisionDataType::AI_RULE_REVISION),
+    );
+    let mut configuration = datadog::Configuration::new();
+    configuration.set_unstable_operation_enabled("v2.CreateAiCustomRuleRevision", true);
+    let api = StaticAnalysisAPI::with_config(configuration);
+    let resp = api
+        .create_ai_custom_rule_revision("my-ai-ruleset".to_string(), "my-ai-rule".to_string(), body)
+        .await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}