diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index b507264fb..e2f197ad5 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -91507,6 +91507,10 @@ components: properties: attributes: $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeleteAttributes" + id: + description: Request ID. This value is echoed back as the response's resource ID. + example: bulk_delete + type: string type: $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeleteRequestDataType" required: @@ -91531,6 +91535,12 @@ components: - BULK_DELETE_RULES SecurityMonitoringRuleBulkDeleteResponse: description: Response for bulk deleting security monitoring rules. + properties: + data: + $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeleteResponseData" + type: object + SecurityMonitoringRuleBulkDeleteResponseAttributes: + description: Attributes for the bulk delete response. properties: deletedRules: description: List of successfully deleted rule IDs. @@ -91543,6 +91553,25 @@ components: type: string type: array type: object + SecurityMonitoringRuleBulkDeleteResponseData: + description: Data for the bulk delete response. + properties: + attributes: + $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeleteResponseAttributes" + id: + description: The identifier of the bulk delete response. + type: string + type: + $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeleteResponseDataType" + type: object + SecurityMonitoringRuleBulkDeleteResponseDataType: + description: The resource type for a bulk delete response. + enum: + - bulk_delete_response + example: bulk_delete_response + type: string + x-enum-varnames: + - BULK_DELETE_RESPONSE SecurityMonitoringRuleBulkExportAttributes: description: Attributes for bulk exporting security monitoring rules. properties: @@ -185417,6 +185446,7 @@ paths: ruleIds: - abc-000-u7q - abc-000-7dd + id: bulk_delete type: bulk_delete_rules schema: $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeletePayload" @@ -185428,10 +185458,14 @@ paths: examples: default: value: - deletedRules: - - abc-000-u7q - - abc-000-7dd - failedRules: [] + data: + attributes: + deletedRules: + - abc-000-u7q + - abc-000-7dd + failedRules: [] + id: bulk_delete_response + type: bulk_delete_response schema: $ref: "#/components/schemas/SecurityMonitoringRuleBulkDeleteResponse" description: OK diff --git a/examples/v2_security-monitoring_BulkDeleteSecurityMonitoringRules.rs b/examples/v2_security-monitoring_BulkDeleteSecurityMonitoringRules.rs index 75287b3a1..5a53d4d6a 100644 --- a/examples/v2_security-monitoring_BulkDeleteSecurityMonitoringRules.rs +++ b/examples/v2_security-monitoring_BulkDeleteSecurityMonitoringRules.rs @@ -8,14 +8,16 @@ use datadog_api_client::datadogV2::model::SecurityMonitoringRuleBulkDeleteReques #[tokio::main] async fn main() { - let body = - SecurityMonitoringRuleBulkDeletePayload::new(SecurityMonitoringRuleBulkDeleteData::new( + let body = SecurityMonitoringRuleBulkDeletePayload::new( + SecurityMonitoringRuleBulkDeleteData::new( SecurityMonitoringRuleBulkDeleteAttributes::new(vec![ "abc-000-u7q".to_string(), "abc-000-7dd".to_string(), ]), SecurityMonitoringRuleBulkDeleteRequestDataType::BULK_DELETE_RULES, - )); + ) + .id("bulk_delete".to_string()), + ); let configuration = datadog::Configuration::new(); let api = SecurityMonitoringAPI::with_config(configuration); let resp = api.bulk_delete_security_monitoring_rules(body).await; diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 293e62041..e26834ff7 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -11286,6 +11286,12 @@ pub mod model_security_monitoring_rule_bulk_delete_request_data_type; pub use self::model_security_monitoring_rule_bulk_delete_request_data_type::SecurityMonitoringRuleBulkDeleteRequestDataType; pub mod model_security_monitoring_rule_bulk_delete_response; pub use self::model_security_monitoring_rule_bulk_delete_response::SecurityMonitoringRuleBulkDeleteResponse; +pub mod model_security_monitoring_rule_bulk_delete_response_data; +pub use self::model_security_monitoring_rule_bulk_delete_response_data::SecurityMonitoringRuleBulkDeleteResponseData; +pub mod model_security_monitoring_rule_bulk_delete_response_attributes; +pub use self::model_security_monitoring_rule_bulk_delete_response_attributes::SecurityMonitoringRuleBulkDeleteResponseAttributes; +pub mod model_security_monitoring_rule_bulk_delete_response_data_type; +pub use self::model_security_monitoring_rule_bulk_delete_response_data_type::SecurityMonitoringRuleBulkDeleteResponseDataType; pub mod model_security_monitoring_rule_bulk_export_payload; pub use self::model_security_monitoring_rule_bulk_export_payload::SecurityMonitoringRuleBulkExportPayload; pub mod model_security_monitoring_rule_bulk_export_data; diff --git a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_data.rs b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_data.rs index 137e39b18..b02b29c05 100644 --- a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_data.rs +++ b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_data.rs @@ -14,6 +14,9 @@ pub struct SecurityMonitoringRuleBulkDeleteData { /// Attributes for bulk deleting security monitoring rules. #[serde(rename = "attributes")] pub attributes: crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteAttributes, + /// Request ID. This value is echoed back as the response's resource ID. + #[serde(rename = "id")] + pub id: Option, /// The resource type for a bulk delete request. #[serde(rename = "type")] pub type_: crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteRequestDataType, @@ -31,12 +34,18 @@ impl SecurityMonitoringRuleBulkDeleteData { ) -> SecurityMonitoringRuleBulkDeleteData { SecurityMonitoringRuleBulkDeleteData { attributes, + id: None, type_, additional_properties: std::collections::BTreeMap::new(), _unparsed: false, } } + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + pub fn additional_properties( mut self, value: std::collections::BTreeMap, @@ -66,6 +75,7 @@ impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteData { let mut attributes: Option< crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteAttributes, > = None; + let mut id: Option = None; let mut type_: Option< crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteRequestDataType, > = None; @@ -80,6 +90,12 @@ impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteData { "attributes" => { attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } "type" => { type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); if let Some(ref _type_) = type_ { @@ -103,6 +119,7 @@ impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteData { let content = SecurityMonitoringRuleBulkDeleteData { attributes, + id, type_, additional_properties, _unparsed, diff --git a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response.rs b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response.rs index 09e9bb316..a6c760239 100644 --- a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response.rs +++ b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response.rs @@ -11,12 +11,9 @@ use std::fmt::{self, Formatter}; #[skip_serializing_none] #[derive(Clone, Debug, PartialEq, Serialize)] pub struct SecurityMonitoringRuleBulkDeleteResponse { - /// List of successfully deleted rule IDs. - #[serde(rename = "deletedRules")] - pub deleted_rules: Option>, - /// List of rule IDs that could not be deleted. - #[serde(rename = "failedRules")] - pub failed_rules: Option>, + /// Data for the bulk delete response. + #[serde(rename = "data")] + pub data: Option, #[serde(flatten)] pub additional_properties: std::collections::BTreeMap, #[serde(skip)] @@ -27,20 +24,17 @@ pub struct SecurityMonitoringRuleBulkDeleteResponse { impl SecurityMonitoringRuleBulkDeleteResponse { pub fn new() -> SecurityMonitoringRuleBulkDeleteResponse { SecurityMonitoringRuleBulkDeleteResponse { - deleted_rules: None, - failed_rules: None, + data: None, additional_properties: std::collections::BTreeMap::new(), _unparsed: false, } } - pub fn deleted_rules(mut self, value: Vec) -> Self { - self.deleted_rules = Some(value); - self - } - - pub fn failed_rules(mut self, value: Vec) -> Self { - self.failed_rules = Some(value); + pub fn data( + mut self, + value: crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseData, + ) -> Self { + self.data = Some(value); self } @@ -76,8 +70,9 @@ impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteResponse { where M: MapAccess<'a>, { - let mut deleted_rules: Option> = None; - let mut failed_rules: Option> = None; + let mut data: Option< + crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseData, + > = None; let mut additional_properties: std::collections::BTreeMap< String, serde_json::Value, @@ -86,19 +81,11 @@ impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteResponse { while let Some((k, v)) = map.next_entry::()? { match k.as_str() { - "deletedRules" => { - if v.is_null() { - continue; - } - deleted_rules = - Some(serde_json::from_value(v).map_err(M::Error::custom)?); - } - "failedRules" => { + "data" => { if v.is_null() { continue; } - failed_rules = - Some(serde_json::from_value(v).map_err(M::Error::custom)?); + data = Some(serde_json::from_value(v).map_err(M::Error::custom)?); } &_ => { if let Ok(value) = serde_json::from_value(v.clone()) { @@ -109,8 +96,7 @@ impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteResponse { } let content = SecurityMonitoringRuleBulkDeleteResponse { - deleted_rules, - failed_rules, + data, additional_properties, _unparsed, }; diff --git a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_attributes.rs b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_attributes.rs new file mode 100644 index 000000000..7e6603d89 --- /dev/null +++ b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_attributes.rs @@ -0,0 +1,124 @@ +// 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}; + +/// Attributes for the bulk delete response. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecurityMonitoringRuleBulkDeleteResponseAttributes { + /// List of successfully deleted rule IDs. + #[serde(rename = "deletedRules")] + pub deleted_rules: Option>, + /// List of rule IDs that could not be deleted. + #[serde(rename = "failedRules")] + pub failed_rules: Option>, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecurityMonitoringRuleBulkDeleteResponseAttributes { + pub fn new() -> SecurityMonitoringRuleBulkDeleteResponseAttributes { + SecurityMonitoringRuleBulkDeleteResponseAttributes { + deleted_rules: None, + failed_rules: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn deleted_rules(mut self, value: Vec) -> Self { + self.deleted_rules = Some(value); + self + } + + pub fn failed_rules(mut self, value: Vec) -> Self { + self.failed_rules = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SecurityMonitoringRuleBulkDeleteResponseAttributes { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteResponseAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecurityMonitoringRuleBulkDeleteResponseAttributesVisitor; + impl<'a> Visitor<'a> for SecurityMonitoringRuleBulkDeleteResponseAttributesVisitor { + type Value = SecurityMonitoringRuleBulkDeleteResponseAttributes; + + 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 deleted_rules: Option> = None; + let mut failed_rules: 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() { + "deletedRules" => { + if v.is_null() { + continue; + } + deleted_rules = + Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "failedRules" => { + if v.is_null() { + continue; + } + failed_rules = + 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 = SecurityMonitoringRuleBulkDeleteResponseAttributes { + deleted_rules, + failed_rules, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SecurityMonitoringRuleBulkDeleteResponseAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_data.rs b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_data.rs new file mode 100644 index 000000000..52d7128e9 --- /dev/null +++ b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_data.rs @@ -0,0 +1,158 @@ +// 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}; + +/// Data for the bulk delete response. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct SecurityMonitoringRuleBulkDeleteResponseData { + /// Attributes for the bulk delete response. + #[serde(rename = "attributes")] + pub attributes: + Option, + /// The identifier of the bulk delete response. + #[serde(rename = "id")] + pub id: Option, + /// The resource type for a bulk delete response. + #[serde(rename = "type")] + pub type_: Option, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl SecurityMonitoringRuleBulkDeleteResponseData { + pub fn new() -> SecurityMonitoringRuleBulkDeleteResponseData { + SecurityMonitoringRuleBulkDeleteResponseData { + attributes: None, + id: None, + type_: None, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn attributes( + mut self, + value: crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseAttributes, + ) -> Self { + self.attributes = Some(value); + self + } + + pub fn id(mut self, value: String) -> Self { + self.id = Some(value); + self + } + + pub fn type_( + mut self, + value: crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseDataType, + ) -> Self { + self.type_ = Some(value); + self + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl Default for SecurityMonitoringRuleBulkDeleteResponseData { + fn default() -> Self { + Self::new() + } +} + +impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteResponseData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct SecurityMonitoringRuleBulkDeleteResponseDataVisitor; + impl<'a> Visitor<'a> for SecurityMonitoringRuleBulkDeleteResponseDataVisitor { + type Value = SecurityMonitoringRuleBulkDeleteResponseData; + + 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 attributes: Option< + crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseAttributes, + > = None; + let mut id: Option = None; + let mut type_: Option< + crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseDataType, + > = 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() { + "attributes" => { + if v.is_null() { + continue; + } + attributes = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "id" => { + if v.is_null() { + continue; + } + id = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + } + "type" => { + if v.is_null() { + continue; + } + type_ = Some(serde_json::from_value(v).map_err(M::Error::custom)?); + if let Some(ref _type_) = type_ { + match _type_ { + crate::datadogV2::model::SecurityMonitoringRuleBulkDeleteResponseDataType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + + let content = SecurityMonitoringRuleBulkDeleteResponseData { + attributes, + id, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(SecurityMonitoringRuleBulkDeleteResponseDataVisitor) + } +} diff --git a/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_data_type.rs b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_data_type.rs new file mode 100644 index 000000000..5ff687b0d --- /dev/null +++ b/src/datadogV2/model/model_security_monitoring_rule_bulk_delete_response_data_type.rs @@ -0,0 +1,48 @@ +// 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 SecurityMonitoringRuleBulkDeleteResponseDataType { + BULK_DELETE_RESPONSE, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for SecurityMonitoringRuleBulkDeleteResponseDataType { + fn to_string(&self) -> String { + match self { + Self::BULK_DELETE_RESPONSE => String::from("bulk_delete_response"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for SecurityMonitoringRuleBulkDeleteResponseDataType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for SecurityMonitoringRuleBulkDeleteResponseDataType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "bulk_delete_response" => Self::BULK_DELETE_RESPONSE, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/tests/scenarios/features/v2/security_monitoring.feature b/tests/scenarios/features/v2/security_monitoring.feature index 10c4c66af..14f3d34a1 100644 --- a/tests/scenarios/features/v2/security_monitoring.feature +++ b/tests/scenarios/features/v2/security_monitoring.feature @@ -232,21 +232,21 @@ Feature: Security Monitoring @generated @skip @team:DataDog/cloud-siem Scenario: Bulk delete security monitoring rules returns "Bad Request" response Given new "BulkDeleteSecurityMonitoringRules" request - And body with value {"data": {"attributes": {"ruleIds": ["abc-000-u7q", "abc-000-7dd"]}, "type": "bulk_delete_rules"}} + And body with value {"data": {"attributes": {"ruleIds": ["abc-000-u7q", "abc-000-7dd"]}, "id": "bulk_delete", "type": "bulk_delete_rules"}} When the request is sent Then the response status is 400 Bad Request @generated @skip @team:DataDog/cloud-siem Scenario: Bulk delete security monitoring rules returns "Not Found" response Given new "BulkDeleteSecurityMonitoringRules" request - And body with value {"data": {"attributes": {"ruleIds": ["abc-000-u7q", "abc-000-7dd"]}, "type": "bulk_delete_rules"}} + And body with value {"data": {"attributes": {"ruleIds": ["abc-000-u7q", "abc-000-7dd"]}, "id": "bulk_delete", "type": "bulk_delete_rules"}} When the request is sent Then the response status is 404 Not Found @generated @skip @team:DataDog/cloud-siem Scenario: Bulk delete security monitoring rules returns "OK" response Given new "BulkDeleteSecurityMonitoringRules" request - And body with value {"data": {"attributes": {"ruleIds": ["abc-000-u7q", "abc-000-7dd"]}, "type": "bulk_delete_rules"}} + And body with value {"data": {"attributes": {"ruleIds": ["abc-000-u7q", "abc-000-7dd"]}, "id": "bulk_delete", "type": "bulk_delete_rules"}} When the request is sent Then the response status is 200 OK