Add specification for the new 'field' on 'hash' action

.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

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)

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;

src/datadogV2/model/model_cloud_workload_security_agent_rule_action.rs

@@ -16,7 +16,7 @@ pub struct CloudWorkloadSecurityAgentRuleAction {
     pub filter: Option<String>,
     /// An empty object indicating the hash action
     #[serde(rename = "hash")]
-    pub hash: Option<std::collections::BTreeMap<String, serde_json::Value>>,
+    pub hash: Option<crate::datadogV2::model::CloudWorkloadSecurityAgentRuleActionHash>,
     /// Kill system call applied on the container matching the rule
     #[serde(rename = "kill")]
     pub kill: Option<crate::datadogV2::model::CloudWorkloadSecurityAgentRuleKill>,
@@ -51,7 +51,10 @@ impl CloudWorkloadSecurityAgentRuleAction {
         self
     }
 
-    pub fn hash(mut self, value: std::collections::BTreeMap<String, serde_json::Value>) -> 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<String> = None;
-                let mut hash: Option<std::collections::BTreeMap<String, serde_json::Value>> = None;
+                let mut hash: Option<
+                    crate::datadogV2::model::CloudWorkloadSecurityAgentRuleActionHash,
+                > = None;
                 let mut kill: Option<crate::datadogV2::model::CloudWorkloadSecurityAgentRuleKill> =
                     None;
                 let mut metadata: Option<

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<String>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[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<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl Default for CloudWorkloadSecurityAgentRuleActionHash {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'de> Deserialize<'de> for CloudWorkloadSecurityAgentRuleActionHash {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    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<M>(self, mut map: M) -> Result<Self::Value, M::Error>
+            where
+                M: MapAccess<'a>,
+            {
+                let mut field: Option<String> = 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::<String, serde_json::Value>()? {
+                    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)
+    }
+}