diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index 42b12a3fb..a18017d35 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -8650,6 +8650,11 @@ components: CloudWorkloadSecurityAgentRuleActionHash: additionalProperties: {} description: An empty object indicating the hash action + properties: + field: + description: Event field to use for the hash computation. + example: process.file + type: string type: object CloudWorkloadSecurityAgentRuleActionMetadata: description: The metadata action applied on the scope matching the rule diff --git a/examples/v2_csm-threats_CreateCSMThreatsAgentRule_1295653933.rs b/examples/v2_csm-threats_CreateCSMThreatsAgentRule_1295653933.rs index e4618f20a..3c816f5a7 100644 --- a/examples/v2_csm-threats_CreateCSMThreatsAgentRule_1295653933.rs +++ b/examples/v2_csm-threats_CreateCSMThreatsAgentRule_1295653933.rs @@ -2,12 +2,12 @@ use datadog_api_client::datadog; use datadog_api_client::datadogV2::api_csm_threats::CSMThreatsAPI; use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleAction; +use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleActionHash; use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleActionSet; use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleCreateAttributes; use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleCreateData; use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleCreateRequest; use datadog_api_client::datadogV2::model::CloudWorkloadSecurityAgentRuleType; -use std::collections::BTreeMap; #[tokio::main] async fn main() { @@ -26,7 +26,8 @@ async fn main() { .scope("process".to_string()) .value("test_value".to_string()), ), - CloudWorkloadSecurityAgentRuleAction::new().hash(BTreeMap::from([])), + CloudWorkloadSecurityAgentRuleAction::new() + .hash(CloudWorkloadSecurityAgentRuleActionHash::new()), ])) .description("My Agent rule with set action".to_string()) .enabled(true) diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 2e6155c97..77c433048 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -4080,6 +4080,8 @@ pub mod model_cloud_workload_security_agent_rule_attributes; pub use self::model_cloud_workload_security_agent_rule_attributes::CloudWorkloadSecurityAgentRuleAttributes; pub mod model_cloud_workload_security_agent_rule_action; pub use self::model_cloud_workload_security_agent_rule_action::CloudWorkloadSecurityAgentRuleAction; +pub mod model_cloud_workload_security_agent_rule_action_hash; +pub use self::model_cloud_workload_security_agent_rule_action_hash::CloudWorkloadSecurityAgentRuleActionHash; pub mod model_cloud_workload_security_agent_rule_kill; pub use self::model_cloud_workload_security_agent_rule_kill::CloudWorkloadSecurityAgentRuleKill; pub mod model_cloud_workload_security_agent_rule_action_metadata; diff --git a/src/datadogV2/model/model_cloud_workload_security_agent_rule_action.rs b/src/datadogV2/model/model_cloud_workload_security_agent_rule_action.rs index f0b44a9fe..2552a9f6a 100644 --- a/src/datadogV2/model/model_cloud_workload_security_agent_rule_action.rs +++ b/src/datadogV2/model/model_cloud_workload_security_agent_rule_action.rs @@ -16,7 +16,7 @@ pub struct CloudWorkloadSecurityAgentRuleAction { pub filter: Option, /// An empty object indicating the hash action #[serde(rename = "hash")] - pub hash: Option>, + pub hash: Option, /// Kill system call applied on the container matching the rule #[serde(rename = "kill")] pub kill: Option, @@ -51,7 +51,10 @@ impl CloudWorkloadSecurityAgentRuleAction { self } - pub fn hash(mut self, value: std::collections::BTreeMap) -> Self { + pub fn hash( + mut self, + value: crate::datadogV2::model::CloudWorkloadSecurityAgentRuleActionHash, + ) -> Self { self.hash = Some(value); self } @@ -113,7 +116,9 @@ impl<'de> Deserialize<'de> for CloudWorkloadSecurityAgentRuleAction { M: MapAccess<'a>, { let mut filter: Option = None; - let mut hash: Option> = None; + let mut hash: Option< + crate::datadogV2::model::CloudWorkloadSecurityAgentRuleActionHash, + > = None; let mut kill: Option = None; let mut metadata: Option< diff --git a/src/datadogV2/model/model_cloud_workload_security_agent_rule_action_hash.rs b/src/datadogV2/model/model_cloud_workload_security_agent_rule_action_hash.rs new file mode 100644 index 000000000..5425153c4 --- /dev/null +++ b/src/datadogV2/model/model_cloud_workload_security_agent_rule_action_hash.rs @@ -0,0 +1,105 @@ +// Unless explicitly stated otherwise all files in this repository are licensed under the Apache-2.0 License. +// This product includes software developed at Datadog (https://www.datadoghq.com/). +// Copyright 2019-Present Datadog, Inc. +use serde::de::{Error, MapAccess, Visitor}; +use serde::{Deserialize, Deserializer, Serialize}; +use serde_with::skip_serializing_none; +use std::fmt::{self, Formatter}; + +/// An empty object indicating the hash action +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct CloudWorkloadSecurityAgentRuleActionHash { + /// Event field to use for the hash computation. + #[serde(rename = "field")] + pub field: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl CloudWorkloadSecurityAgentRuleActionHash { + pub fn new() -> CloudWorkloadSecurityAgentRuleActionHash { + CloudWorkloadSecurityAgentRuleActionHash { + field: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn field(mut self, value: String) -> Self { + self.field = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for CloudWorkloadSecurityAgentRuleActionHash { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for CloudWorkloadSecurityAgentRuleActionHash { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct CloudWorkloadSecurityAgentRuleActionHashVisitor; + impl<'a> Visitor<'a> for CloudWorkloadSecurityAgentRuleActionHashVisitor { + type Value = CloudWorkloadSecurityAgentRuleActionHash; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut field: Option = None; + let mut additional_properties: std::collections::BTreeMap< + String, + serde_json::Value, + > = std::collections::BTreeMap::new(); + let mut _unparsed = false; + + while let Some((k, v)) = map.next_entry::()? { + match k.as_str() { + "field" => { + if v.is_null() { + continue; + } + field = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = CloudWorkloadSecurityAgentRuleActionHash { + field, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(CloudWorkloadSecurityAgentRuleActionHashVisitor) + } +}