Regenerate client from commit af216d4e of spec repo

Author: ci.datadog-api-spec

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-08 19:08:05.438773",
-            "spec_repo_commit": "7b042e12"
+            "regenerated": "2025-07-09 07:40:20.345499",
+            "spec_repo_commit": "af216d4e"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-08 19:08:05.457615",
-            "spec_repo_commit": "7b042e12"
+            "regenerated": "2025-07-09 07:40:20.361618",
+            "spec_repo_commit": "af216d4e"
         }
     }
 }

.generator/schemas/v2/openapi.yaml

@@ -10668,6 +10668,7 @@ components:
       - $ref: '#/components/schemas/CustomDestinationForwardDestinationSplunk'
       - $ref: '#/components/schemas/CustomDestinationForwardDestinationElasticsearch'
       - $ref: '#/components/schemas/CustomDestinationForwardDestinationMicrosoftSentinel'
+      - $ref: '#/components/schemas/CustomDestinationForwardDestinationGoogleSecurityOperations'
     CustomDestinationForwardDestinationElasticsearch:
       description: The Elasticsearch destination.
       properties:
@@ -10725,6 +10726,42 @@ components:
       type: string
       x-enum-varnames:
       - ELASTICSEARCH
+    CustomDestinationForwardDestinationGoogleSecurityOperations:
+      description: The Google Security Operations destination.
+      properties:
+        auth:
+          $ref: '#/components/schemas/CustomDestinationGoogleSecurityOperationsDestinationAuth'
+        customer_id:
+          description: The customer ID of the Google Security Operations account.
+          example: 123-456-7890
+          type: string
+        namespace:
+          description: The namespace of the Google Security Operations account.
+          example: google-security-operations-namespace
+          type: string
+        regional_endpoint:
+          description: The `CustomDestinationForwardDestinationGoogleSecurityOperations`
+            `regional_endpoint`.
+          example: https://malachiteingestion-pa.googleapis.com
+          type: string
+        type:
+          $ref: '#/components/schemas/CustomDestinationForwardDestinationGoogleSecurityOperationsType'
+      required:
+      - type
+      - customer_id
+      - regional_endpoint
+      - namespace
+      - auth
+      type: object
+    CustomDestinationForwardDestinationGoogleSecurityOperationsType:
+      default: google_security_operations
+      description: Type of the Google Security Operations destination.
+      enum:
+      - google_security_operations
+      example: google_security_operations
+      type: string
+      x-enum-varnames:
+      - GOOGLE_SECURITY_OPERATIONS
     CustomDestinationForwardDestinationHttp:
       description: The HTTP destination.
       properties:
@@ -10826,6 +10863,55 @@ components:
       type: string
       x-enum-varnames:
       - SPLUNK_HEC
+    CustomDestinationGoogleSecurityOperationsDestinationAuth:
+      description: Google Security Operations destination authentication.
+      properties:
+        client_email:
+          description: The Google Security Operations client email address.
+          example: [email protected]
+          type: string
+        client_id:
+          description: The Google Security Operations client ID. This field is not
+            returned by the API.
+          example: def123456
+          type: string
+          writeOnly: true
+        private_key:
+          description: The Google Security Operations private key. This field is not
+            returned by the API.
+          example: '-----BEGIN PRIVATE KEY-----\nMIIEvAIBADANBgkqhkiG9w0BAQEFAASCBK...\n-----END
+            PRIVATE KEY-----\n'
+          type: string
+          writeOnly: true
+        private_key_id:
+          description: The Google Security Operations private key ID. This field is
+            not returned by the API.
+          example: abc12345678
+          type: string
+          writeOnly: true
+        project_id:
+          description: The Google Security Operations project ID.
+          example: gcp-project
+          type: string
+        type:
+          $ref: '#/components/schemas/CustomDestinationGoogleSecurityOperationsDestinationAuthType'
+      required:
+      - type
+      - project_id
+      - private_key_id
+      - client_email
+      - client_id
+      - private_key
+      type: object
+    CustomDestinationGoogleSecurityOperationsDestinationAuthType:
+      default: gcp_private_key
+      description: Type of the Google Security Operations destination authentication.
+      enum:
+      - gcp_private_key
+      example: gcp_private_key
+      type: string
+      x-enum-varnames:
+      - GCP_PRIVATE_KEY
     CustomDestinationHttpDestinationAuth:
       description: Authentication method of the HTTP requests.
       oneOf:

examples/v2_logs-custom-destinations_CreateLogsCustomDestination_1006705740.rs

@@ -0,0 +1,62 @@
+// Create a Google Security Operations custom destination returns "OK" response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_logs_custom_destinations::LogsCustomDestinationsAPI;
+use datadog_api_client::datadogV2::model::CustomDestinationAttributeTagsRestrictionListType;
+use datadog_api_client::datadogV2::model::CustomDestinationCreateRequest;
+use datadog_api_client::datadogV2::model::CustomDestinationCreateRequestAttributes;
+use datadog_api_client::datadogV2::model::CustomDestinationCreateRequestDefinition;
+use datadog_api_client::datadogV2::model::CustomDestinationForwardDestination;
+use datadog_api_client::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperations;
+use datadog_api_client::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperationsType;
+use datadog_api_client::datadogV2::model::CustomDestinationGoogleSecurityOperationsDestinationAuth;
+use datadog_api_client::datadogV2::model::CustomDestinationGoogleSecurityOperationsDestinationAuthType;
+use datadog_api_client::datadogV2::model::CustomDestinationType;
+
+#[tokio::main]
+async fn main() {
+    let body =
+        CustomDestinationCreateRequest
+        ::new().data(
+            CustomDestinationCreateRequestDefinition::new(
+                CustomDestinationCreateRequestAttributes::new(
+                    CustomDestinationForwardDestination::CustomDestinationForwardDestinationGoogleSecurityOperations(
+                        Box::new(
+                            CustomDestinationForwardDestinationGoogleSecurityOperations::new(
+                                CustomDestinationGoogleSecurityOperationsDestinationAuth::new(
+                                    "[email protected]".to_string(),
+                                    "def123456".to_string(),
+                                    r#"-----BEGIN PRIVATE KEY-----
+MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBK...
+-----END PRIVATE KEY-----
+"#.to_string(),
+                                    "abc12345678".to_string(),
+                                    "gcp-project".to_string(),
+                                    CustomDestinationGoogleSecurityOperationsDestinationAuthType::GCP_PRIVATE_KEY,
+                                ),
+                                "123-456-7890".to_string(),
+                                "google-security-operations-namespace".to_string(),
+                                "https://malachiteingestion-pa.googleapis.com".to_string(),
+                                CustomDestinationForwardDestinationGoogleSecurityOperationsType
+                                ::GOOGLE_SECURITY_OPERATIONS,
+                            ),
+                        ),
+                    ),
+                    "Nginx logs".to_string(),
+                )
+                    .enabled(false)
+                    .forward_tags(false)
+                    .forward_tags_restriction_list(vec!["datacenter".to_string(), "host".to_string()])
+                    .forward_tags_restriction_list_type(CustomDestinationAttributeTagsRestrictionListType::ALLOW_LIST)
+                    .query("source:nginx".to_string()),
+                CustomDestinationType::CUSTOM_DESTINATION,
+            ),
+        );
+    let configuration = datadog::Configuration::new();
+    let api = LogsCustomDestinationsAPI::with_config(configuration);
+    let resp = api.create_logs_custom_destination(body).await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/model/mod.rs

@@ -2360,6 +2360,14 @@ pub mod model_custom_destination_forward_destination_microsoft_sentinel;
 pub use self::model_custom_destination_forward_destination_microsoft_sentinel::CustomDestinationForwardDestinationMicrosoftSentinel;
 pub mod model_custom_destination_forward_destination_microsoft_sentinel_type;
 pub use self::model_custom_destination_forward_destination_microsoft_sentinel_type::CustomDestinationForwardDestinationMicrosoftSentinelType;
+pub mod model_custom_destination_forward_destination_google_security_operations;
+pub use self::model_custom_destination_forward_destination_google_security_operations::CustomDestinationForwardDestinationGoogleSecurityOperations;
+pub mod model_custom_destination_google_security_operations_destination_auth;
+pub use self::model_custom_destination_google_security_operations_destination_auth::CustomDestinationGoogleSecurityOperationsDestinationAuth;
+pub mod model_custom_destination_google_security_operations_destination_auth_type;
+pub use self::model_custom_destination_google_security_operations_destination_auth_type::CustomDestinationGoogleSecurityOperationsDestinationAuthType;
+pub mod model_custom_destination_forward_destination_google_security_operations_type;
+pub use self::model_custom_destination_forward_destination_google_security_operations_type::CustomDestinationForwardDestinationGoogleSecurityOperationsType;
 pub mod model_custom_destination_forward_destination;
 pub use self::model_custom_destination_forward_destination::CustomDestinationForwardDestination;
 pub mod model_custom_destination_response;

src/datadogV2/model/model_custom_destination_forward_destination.rs

@@ -20,6 +20,9 @@ pub enum CustomDestinationForwardDestination {
     CustomDestinationForwardDestinationMicrosoftSentinel(
         Box<crate::datadogV2::model::CustomDestinationForwardDestinationMicrosoftSentinel>,
     ),
+    CustomDestinationForwardDestinationGoogleSecurityOperations(
+        Box<crate::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperations>,
+    ),
     UnparsedObject(crate::datadog::UnparsedObject),
 }
 
@@ -69,6 +72,11 @@ impl<'de> Deserialize<'de> for CustomDestinationForwardDestination {
                 return Ok(CustomDestinationForwardDestination::CustomDestinationForwardDestinationMicrosoftSentinel(_v));
             }
         }
+        if let Ok(_v) = serde_json::from_value::<Box<crate::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperations>>(value.clone()) {
+			if !_v._unparsed {
+                return Ok(CustomDestinationForwardDestination::CustomDestinationForwardDestinationGoogleSecurityOperations(_v));
+            }
+        }
 
         return Ok(CustomDestinationForwardDestination::UnparsedObject(
             crate::datadog::UnparsedObject { value },

src/datadogV2/model/model_custom_destination_forward_destination_google_security_operations.rs

@@ -0,0 +1,152 @@
+// 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};
+
+/// The Google Security Operations destination.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct CustomDestinationForwardDestinationGoogleSecurityOperations {
+    /// Google Security Operations destination authentication.
+    #[serde(rename = "auth")]
+    pub auth: crate::datadogV2::model::CustomDestinationGoogleSecurityOperationsDestinationAuth,
+    /// The customer ID of the Google Security Operations account.
+    #[serde(rename = "customer_id")]
+    pub customer_id: String,
+    /// The namespace of the Google Security Operations account.
+    #[serde(rename = "namespace")]
+    pub namespace: String,
+    /// The `CustomDestinationForwardDestinationGoogleSecurityOperations` `regional_endpoint`.
+    #[serde(rename = "regional_endpoint")]
+    pub regional_endpoint: String,
+    /// Type of the Google Security Operations destination.
+    #[serde(rename = "type")]
+    pub type_:
+        crate::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperationsType,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl CustomDestinationForwardDestinationGoogleSecurityOperations {
+    pub fn new(
+        auth: crate::datadogV2::model::CustomDestinationGoogleSecurityOperationsDestinationAuth,
+        customer_id: String,
+        namespace: String,
+        regional_endpoint: String,
+        type_: crate::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperationsType,
+    ) -> CustomDestinationForwardDestinationGoogleSecurityOperations {
+        CustomDestinationForwardDestinationGoogleSecurityOperations {
+            auth,
+            customer_id,
+            namespace,
+            regional_endpoint,
+            type_,
+            additional_properties: std::collections::BTreeMap::new(),
+            _unparsed: false,
+        }
+    }
+
+    pub fn additional_properties(
+        mut self,
+        value: std::collections::BTreeMap<String, serde_json::Value>,
+    ) -> Self {
+        self.additional_properties = value;
+        self
+    }
+}
+
+impl<'de> Deserialize<'de> for CustomDestinationForwardDestinationGoogleSecurityOperations {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct CustomDestinationForwardDestinationGoogleSecurityOperationsVisitor;
+        impl<'a> Visitor<'a> for CustomDestinationForwardDestinationGoogleSecurityOperationsVisitor {
+            type Value = CustomDestinationForwardDestinationGoogleSecurityOperations;
+
+            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 auth: Option<crate::datadogV2::model::CustomDestinationGoogleSecurityOperationsDestinationAuth> = None;
+                let mut customer_id: Option<String> = None;
+                let mut namespace: Option<String> = None;
+                let mut regional_endpoint: Option<String> = None;
+                let mut type_: Option<crate::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperationsType> = 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() {
+                        "auth" => {
+                            auth = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "customer_id" => {
+                            customer_id =
+                                Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "namespace" => {
+                            namespace = Some(serde_json::from_value(v).map_err(M::Error::custom)?);
+                        }
+                        "regional_endpoint" => {
+                            regional_endpoint =
+                                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_ {
+                                match _type_ {
+                                    crate::datadogV2::model::CustomDestinationForwardDestinationGoogleSecurityOperationsType::UnparsedObject(_type_) => {
+                                        _unparsed = true;
+                                    },
+                                    _ => {}
+                                }
+                            }
+                        }
+                        &_ => {
+                            if let Ok(value) = serde_json::from_value(v.clone()) {
+                                additional_properties.insert(k, value);
+                            }
+                        }
+                    }
+                }
+                let auth = auth.ok_or_else(|| M::Error::missing_field("auth"))?;
+                let customer_id =
+                    customer_id.ok_or_else(|| M::Error::missing_field("customer_id"))?;
+                let namespace = namespace.ok_or_else(|| M::Error::missing_field("namespace"))?;
+                let regional_endpoint = regional_endpoint
+                    .ok_or_else(|| M::Error::missing_field("regional_endpoint"))?;
+                let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?;
+
+                let content = CustomDestinationForwardDestinationGoogleSecurityOperations {
+                    auth,
+                    customer_id,
+                    namespace,
+                    regional_endpoint,
+                    type_,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer
+            .deserialize_any(CustomDestinationForwardDestinationGoogleSecurityOperationsVisitor)
+    }
+}