Regenerate client from commit 8f16f04b of spec repo

ci.datadog-api-spec · ci.datadog-api-spec · commit a601848ad121 · 2024-10-07T15:46:14.000Z
diff --git a/.apigentools-info b/.apigentools-info
@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2024-10-07 14:32:07.351355",
-            "spec_repo_commit": "ef7c2778"
+            "regenerated": "2024-10-07 15:40:46.984706",
+            "spec_repo_commit": "8f16f04b"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2024-10-07 14:32:07.365583",
-            "spec_repo_commit": "ef7c2778"
+            "regenerated": "2024-10-07 15:40:46.999308",
+            "spec_repo_commit": "8f16f04b"
         }
     }
 }
diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml
@@ -9230,6 +9230,8 @@ components:
           $ref: '#/components/schemas/FindingStatus'
         tags:
           $ref: '#/components/schemas/FindingTags'
+        vulnerability_type:
+          $ref: '#/components/schemas/FindingVulnerabilityType'
       type: object
     FindingEvaluation:
       description: The evaluation of the finding.
@@ -9363,6 +9365,20 @@ components:
       type: string
       x-enum-varnames:
       - FINDING
+    FindingVulnerabilityType:
+      description: The vulnerability type of the finding.
+      enum:
+      - misconfiguration
+      - attack_path
+      - identity_risk
+      - api_security
+      example: misconfiguration
+      type: string
+      x-enum-varnames:
+      - MISCONFIGURATION
+      - ATTACK_PATH
+      - IDENTITY_RISK
+      - API_SECURITY
     FormulaLimit:
       description: 'Message for specifying limits to the number of values returned
         by a query.
@@ -34371,6 +34387,16 @@ paths:
         required: false
         schema:
           $ref: '#/components/schemas/FindingStatus'
+      - description: Return findings that match the selected vulnerability types (repeatable).
+        example:
+        - misconfiguration
+        in: query
+        name: filter[vulnerability_type]
+        required: false
+        schema:
+          items:
+            $ref: '#/components/schemas/FindingVulnerabilityType'
+          type: array
       responses:
         '200':
           content:
diff --git a/src/datadogV2/api/api_security_monitoring.rs b/src/datadogV2/api/api_security_monitoring.rs
@@ -57,6 +57,8 @@ pub struct ListFindingsOptionalParams {
     pub filter_evaluation: Option<crate::datadogV2::model::FindingEvaluation>,
     /// Return only findings with the specified status.
     pub filter_status: Option<crate::datadogV2::model::FindingStatus>,
+    /// Return findings that match the selected vulnerability types (repeatable).
+    pub filter_vulnerability_type: Option<Vec<crate::datadogV2::model::FindingVulnerabilityType>>,
 }
 
 impl ListFindingsOptionalParams {
@@ -120,6 +122,14 @@ impl ListFindingsOptionalParams {
         self.filter_status = Some(value);
         self
     }
+    /// Return findings that match the selected vulnerability types (repeatable).
+    pub fn filter_vulnerability_type(
+        mut self,
+        value: Vec<crate::datadogV2::model::FindingVulnerabilityType>,
+    ) -> Self {
+        self.filter_vulnerability_type = Some(value);
+        self
+    }
 }
 
 /// ListSecurityMonitoringRulesOptionalParams is a struct for passing parameters to the method [`SecurityMonitoringAPI::list_security_monitoring_rules`]
@@ -2749,6 +2759,7 @@ impl SecurityMonitoringAPI {
         let filter_discovery_timestamp = params.filter_discovery_timestamp;
         let filter_evaluation = params.filter_evaluation;
         let filter_status = params.filter_status;
+        let filter_vulnerability_type = params.filter_vulnerability_type;
 
         let local_client = &self.client;
 
@@ -2811,6 +2822,17 @@ impl SecurityMonitoringAPI {
             local_req_builder =
                 local_req_builder.query(&[("filter[status]", &local_query_param.to_string())]);
         };
+        if let Some(ref local) = filter_vulnerability_type {
+            local_req_builder = local_req_builder.query(&[(
+                "filter[vulnerability_type]",
+                &local
+                    .iter()
+                    .map(|p| p.to_string())
+                    .collect::<Vec<String>>()
+                    .join(",")
+                    .to_string(),
+            )]);
+        };
 
         // build headers
         let mut headers = HeaderMap::new();
diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs
@@ -1960,6 +1960,8 @@ pub mod model_finding_evaluation;
 pub use self::model_finding_evaluation::FindingEvaluation;
 pub mod model_finding_status;
 pub use self::model_finding_status::FindingStatus;
+pub mod model_finding_vulnerability_type;
+pub use self::model_finding_vulnerability_type::FindingVulnerabilityType;
 pub mod model_list_findings_response;
 pub use self::model_list_findings_response::ListFindingsResponse;
 pub mod model_finding;
diff --git a/src/datadogV2/model/model_finding_attributes.rs b/src/datadogV2/model/model_finding_attributes.rs
@@ -38,6 +38,9 @@ pub struct FindingAttributes {
     /// The tags associated with this finding.
     #[serde(rename = "tags")]
     pub tags: Option<Vec<String>>,
+    /// The vulnerability type of the finding.
+    #[serde(rename = "vulnerability_type")]
+    pub vulnerability_type: Option<crate::datadogV2::model::FindingVulnerabilityType>,
     #[serde(flatten)]
     pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
     #[serde(skip)]
@@ -57,6 +60,7 @@ impl FindingAttributes {
             rule: None,
             status: None,
             tags: None,
+            vulnerability_type: None,
             additional_properties: std::collections::BTreeMap::new(),
             _unparsed: false,
         }
@@ -107,6 +111,14 @@ impl FindingAttributes {
         self
     }
 
+    pub fn vulnerability_type(
+        mut self,
+        value: crate::datadogV2::model::FindingVulnerabilityType,
+    ) -> Self {
+        self.vulnerability_type = Some(value);
+        self
+    }
+
     pub fn additional_properties(
         mut self,
         value: std::collections::BTreeMap<String, serde_json::Value>,
@@ -148,6 +160,9 @@ impl<'de> Deserialize<'de> for FindingAttributes {
                 let mut rule: Option<crate::datadogV2::model::FindingRule> = None;
                 let mut status: Option<crate::datadogV2::model::FindingStatus> = None;
                 let mut tags: Option<Vec<String>> = None;
+                let mut vulnerability_type: Option<
+                    crate::datadogV2::model::FindingVulnerabilityType,
+                > = None;
                 let mut additional_properties: std::collections::BTreeMap<
                     String,
                     serde_json::Value,
@@ -233,6 +248,21 @@ impl<'de> Deserialize<'de> for FindingAttributes {
                             }
                             tags = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
                         }
+                        "vulnerability_type" => {
+                            if v.is_null() {
+                                continue;
+                            }
+                            vulnerability_type =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                            if let Some(ref _vulnerability_type) = vulnerability_type {
+                                match _vulnerability_type {
+                                    crate::datadogV2::model::FindingVulnerabilityType::UnparsedObject(_vulnerability_type) => {
+                                        _unparsed = true;
+                                    },
+                                    _ => {}
+                                }
+                            }
+                        }
                         &_ => {
                             if let Ok(value) = serde_json::from_value(v.clone()) {
                                 additional_properties.insert(k, value);
@@ -251,6 +281,7 @@ impl<'de> Deserialize<'de> for FindingAttributes {
                     rule,
                     status,
                     tags,
+                    vulnerability_type,
                     additional_properties,
                     _unparsed,
                 };
diff --git a/src/datadogV2/model/model_finding_vulnerability_type.rs b/src/datadogV2/model/model_finding_vulnerability_type.rs
@@ -0,0 +1,57 @@
+// 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::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[non_exhaustive]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum FindingVulnerabilityType {
+    MISCONFIGURATION,
+    ATTACK_PATH,
+    IDENTITY_RISK,
+    API_SECURITY,
+    UnparsedObject(crate::datadog::UnparsedObject),
+}
+
+impl ToString for FindingVulnerabilityType {
+    fn to_string(&self) -> String {
+        match self {
+            Self::MISCONFIGURATION => String::from("misconfiguration"),
+            Self::ATTACK_PATH => String::from("attack_path"),
+            Self::IDENTITY_RISK => String::from("identity_risk"),
+            Self::API_SECURITY => String::from("api_security"),
+            Self::UnparsedObject(v) => v.value.to_string(),
+        }
+    }
+}
+
+impl Serialize for FindingVulnerabilityType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match self {
+            Self::UnparsedObject(v) => v.serialize(serializer),
+            _ => serializer.serialize_str(self.to_string().as_str()),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for FindingVulnerabilityType {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s: String = String::deserialize(deserializer)?;
+        Ok(match s.as_str() {
+            "misconfiguration" => Self::MISCONFIGURATION,
+            "attack_path" => Self::ATTACK_PATH,
+            "identity_risk" => Self::IDENTITY_RISK,
+            "api_security" => Self::API_SECURITY,
+            _ => Self::UnparsedObject(crate::datadog::UnparsedObject {
+                value: serde_json::Value::String(s.into()),
+            }),
+        })
+    }
+}
diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs
@@ -18251,6 +18251,9 @@ fn test_v2_list_findings(world: &mut DatadogWorld, _parameters: &HashMap<String,
     let filter_status = _parameters
         .get("filter[status]")
         .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap()));
+    let filter_vulnerability_type = _parameters
+        .get("filter[vulnerability_type]")
+        .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap()));
     let mut params = datadogV2::api_security_monitoring::ListFindingsOptionalParams::default();
     params.page_limit = page_limit;
     params.snapshot_timestamp = snapshot_timestamp;
@@ -18264,6 +18267,7 @@ fn test_v2_list_findings(world: &mut DatadogWorld, _parameters: &HashMap<String,
     params.filter_discovery_timestamp = filter_discovery_timestamp;
     params.filter_evaluation = filter_evaluation;
     params.filter_status = filter_status;
+    params.filter_vulnerability_type = filter_vulnerability_type;
     let response = match block_on(api.list_findings_with_http_info(params)) {
         Ok(response) => response,
         Err(error) => {
@@ -18326,6 +18330,9 @@ fn test_v2_list_findings_with_pagination(
     let filter_status = _parameters
         .get("filter[status]")
         .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap()));
+    let filter_vulnerability_type = _parameters
+        .get("filter[vulnerability_type]")
+        .and_then(|param| Some(serde_json::from_value(param.clone()).unwrap()));
     let mut params = datadogV2::api_security_monitoring::ListFindingsOptionalParams::default();
     params.page_limit = page_limit;
     params.snapshot_timestamp = snapshot_timestamp;
@@ -18339,6 +18346,7 @@ fn test_v2_list_findings_with_pagination(
     params.filter_discovery_timestamp = filter_discovery_timestamp;
     params.filter_evaluation = filter_evaluation;
     params.filter_status = filter_status;
+    params.filter_vulnerability_type = filter_vulnerability_type;
     let response = api.list_findings_with_pagination(params);
     let mut result = Vec::new();
 

Original file line number	Diff line number	Diff line change
`@@ -4,13 +4,13 @@`
`4`	`4`	`"spec_versions": {`
`5`	`5`	`"v1": {`
`6`	`6`	`"apigentools_version": "1.6.6",`
`7`		`- "regenerated": "2024-10-07 14:32:07.351355",`
`8`		`- "spec_repo_commit": "ef7c2778"`
	`7`	`+ "regenerated": "2024-10-07 15:40:46.984706",`
	`8`	`+ "spec_repo_commit": "8f16f04b"`
`9`	`9`	`},`
`10`	`10`	`"v2": {`
`11`	`11`	`"apigentools_version": "1.6.6",`
`12`		`- "regenerated": "2024-10-07 14:32:07.365583",`
`13`		`- "spec_repo_commit": "ef7c2778"`
	`12`	`+ "regenerated": "2024-10-07 15:40:46.999308",`
	`13`	`+ "spec_repo_commit": "8f16f04b"`
`14`	`14`	`}`
`15`	`15`	`}`
`16`	`16`	`}`