Regenerate client from commit de2517ad 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-02 12:38:40.410886",
-            "spec_repo_commit": "4fd1c189"
+            "regenerated": "2025-07-02 16:34:47.090537",
+            "spec_repo_commit": "de2517ad"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-02 12:38:40.427530",
-            "spec_repo_commit": "4fd1c189"
+            "regenerated": "2025-07-02 16:34:47.107437",
+            "spec_repo_commit": "de2517ad"
         }
     }
 }

.generator/schemas/v2/openapi.yaml

@@ -1536,6 +1536,54 @@ components:
       - type
       - credentials
       type: object
+    AWSIntegrationIamPermissionsResponse:
+      description: AWS Integration IAM Permissions response body.
+      properties:
+        data:
+          $ref: '#/components/schemas/AWSIntegrationIamPermissionsResponseData'
+      required:
+      - data
+      type: object
+    AWSIntegrationIamPermissionsResponseAttributes:
+      description: AWS Integration IAM Permissions response attributes.
+      properties:
+        permissions:
+          description: List of AWS IAM permissions required for the integration.
+          example:
+          - account:GetContactInformation
+          - amplify:ListApps
+          - amplify:ListArtifacts
+          - amplify:ListBackendEnvironments
+          - amplify:ListBranches
+          items:
+            example: account:GetContactInformation
+            type: string
+          type: array
+      required:
+      - permissions
+      type: object
+    AWSIntegrationIamPermissionsResponseData:
+      description: AWS Integration IAM Permissions response data.
+      properties:
+        attributes:
+          $ref: '#/components/schemas/AWSIntegrationIamPermissionsResponseAttributes'
+        id:
+          default: permissions
+          description: The `AWSIntegrationIamPermissionsResponseData` `id`.
+          example: permissions
+          type: string
+        type:
+          $ref: '#/components/schemas/AWSIntegrationIamPermissionsResponseDataType'
+      type: object
+    AWSIntegrationIamPermissionsResponseDataType:
+      default: permissions
+      description: The `AWSIntegrationIamPermissionsResponseData` `type`.
+      enum:
+      - permissions
+      example: permissions
+      type: string
+      x-enum-varnames:
+      - PERMISSIONS
     AWSIntegrationType:
       description: The definition of `AWSIntegrationType` object.
       enum:
@@ -49519,6 +49567,22 @@ paths:
       x-unstable: '**Note: This endpoint is in Preview. If you have any feedback,
 
         contact [Datadog support](https://docs.datadoghq.com/help/).**'
+  /api/v2/integration/aws/iam_permissions:
+    get:
+      description: Get all AWS IAM permissions required for the AWS integration.
+      operationId: GetAWSIntegrationIAMPermissions
+      responses:
+        '200':
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/AWSIntegrationIamPermissionsResponse'
+          description: AWS IAM Permissions object
+        '429':
+          $ref: '#/components/responses/TooManyRequestsResponse'
+      summary: Get AWS integration IAM permissions
+      tags:
+      - AWS Integration
   /api/v2/integration/aws/logs/services:
     get:
       description: Get a list of AWS services that can send logs to Datadog.

examples/v2_aws-integration_GetAWSIntegrationIAMPermissions.rs

@@ -0,0 +1,16 @@
+// Get AWS integration IAM permissions returns "AWS IAM Permissions object"
+// response
+use datadog_api_client::datadog;
+use datadog_api_client::datadogV2::api_aws_integration::AWSIntegrationAPI;
+
+#[tokio::main]
+async fn main() {
+    let configuration = datadog::Configuration::new();
+    let api = AWSIntegrationAPI::with_config(configuration);
+    let resp = api.get_aws_integration_iam_permissions().await;
+    if let Ok(value) = resp {
+        println!("{:#?}", value);
+    } else {
+        println!("{:#?}", resp.unwrap_err());
+    }
+}

src/datadogV2/api/api_aws_integration.rs

@@ -59,6 +59,14 @@ pub enum GetAWSAccountError {
     UnknownValue(serde_json::Value),
 }
 
+/// GetAWSIntegrationIAMPermissionsError is a struct for typed errors of method [`AWSIntegrationAPI::get_aws_integration_iam_permissions`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum GetAWSIntegrationIAMPermissionsError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// ListAWSAccountsError is a struct for typed errors of method [`AWSIntegrationAPI::list_aws_accounts`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -640,6 +648,116 @@ impl AWSIntegrationAPI {
         }
     }
 
+    /// Get all AWS IAM permissions required for the AWS integration.
+    pub async fn get_aws_integration_iam_permissions(
+        &self,
+    ) -> Result<
+        crate::datadogV2::model::AWSIntegrationIamPermissionsResponse,
+        datadog::Error<GetAWSIntegrationIAMPermissionsError>,
+    > {
+        match self
+            .get_aws_integration_iam_permissions_with_http_info()
+            .await
+        {
+            Ok(response_content) => {
+                if let Some(e) = response_content.entity {
+                    Ok(e)
+                } else {
+                    Err(datadog::Error::Serde(serde::de::Error::custom(
+                        "response content was None",
+                    )))
+                }
+            }
+            Err(err) => Err(err),
+        }
+    }
+
+    /// Get all AWS IAM permissions required for the AWS integration.
+    pub async fn get_aws_integration_iam_permissions_with_http_info(
+        &self,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::AWSIntegrationIamPermissionsResponse>,
+        datadog::Error<GetAWSIntegrationIAMPermissionsError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.get_aws_integration_iam_permissions";
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/integration/aws/iam_permissions",
+            local_configuration.get_operation_host(operation_id)
+        );
+        let mut local_req_builder =
+            local_client.request(reqwest::Method::GET, local_uri_str.as_str());
+
+        // build headers
+        let mut headers = HeaderMap::new();
+        headers.insert("Accept", HeaderValue::from_static("application/json"));
+
+        // build user agent
+        match HeaderValue::from_str(local_configuration.user_agent.as_str()) {
+            Ok(user_agent) => headers.insert(reqwest::header::USER_AGENT, user_agent),
+            Err(e) => {
+                log::warn!("Failed to parse user agent header: {e}, falling back to default");
+                headers.insert(
+                    reqwest::header::USER_AGENT,
+                    HeaderValue::from_static(datadog::DEFAULT_USER_AGENT.as_str()),
+                )
+            }
+        };
+
+        // build auth
+        if let Some(local_key) = local_configuration.auth_keys.get("apiKeyAuth") {
+            headers.insert(
+                "DD-API-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-API-KEY header"),
+            );
+        };
+        if let Some(local_key) = local_configuration.auth_keys.get("appKeyAuth") {
+            headers.insert(
+                "DD-APPLICATION-KEY",
+                HeaderValue::from_str(local_key.key.as_str())
+                    .expect("failed to parse DD-APPLICATION-KEY header"),
+            );
+        };
+
+        local_req_builder = local_req_builder.headers(headers);
+        let local_req = local_req_builder.build()?;
+        log::debug!("request content: {:?}", local_req.body());
+        let local_resp = local_client.execute(local_req).await?;
+
+        let local_status = local_resp.status();
+        let local_content = local_resp.text().await?;
+        log::debug!("response content: {}", local_content);
+
+        if !local_status.is_client_error() && !local_status.is_server_error() {
+            match serde_json::from_str::<
+                crate::datadogV2::model::AWSIntegrationIamPermissionsResponse,
+            >(&local_content)
+            {
+                Ok(e) => {
+                    return Ok(datadog::ResponseContent {
+                        status: local_status,
+                        content: local_content,
+                        entity: Some(e),
+                    })
+                }
+                Err(e) => return Err(datadog::Error::Serde(e)),
+            };
+        } else {
+            let local_entity: Option<GetAWSIntegrationIAMPermissionsError> =
+                serde_json::from_str(&local_content).ok();
+            let local_error = datadog::ResponseContent {
+                status: local_status,
+                content: local_content,
+                entity: local_entity,
+            };
+            Err(datadog::Error::ResponseError(local_error))
+        }
+    }
+
     /// Get a list of AWS Account Integration Configs.
     pub async fn list_aws_accounts(
         &self,

src/datadogV2/model/mod.rs

@@ -1916,6 +1916,14 @@ pub mod model_aws_new_external_id_response_attributes;
 pub use self::model_aws_new_external_id_response_attributes::AWSNewExternalIDResponseAttributes;
 pub mod model_aws_new_external_id_response_data_type;
 pub use self::model_aws_new_external_id_response_data_type::AWSNewExternalIDResponseDataType;
+pub mod model_aws_integration_iam_permissions_response;
+pub use self::model_aws_integration_iam_permissions_response::AWSIntegrationIamPermissionsResponse;
+pub mod model_aws_integration_iam_permissions_response_data;
+pub use self::model_aws_integration_iam_permissions_response_data::AWSIntegrationIamPermissionsResponseData;
+pub mod model_aws_integration_iam_permissions_response_attributes;
+pub use self::model_aws_integration_iam_permissions_response_attributes::AWSIntegrationIamPermissionsResponseAttributes;
+pub mod model_aws_integration_iam_permissions_response_data_type;
+pub use self::model_aws_integration_iam_permissions_response_data_type::AWSIntegrationIamPermissionsResponseDataType;
 pub mod model_aws_logs_services_response;
 pub use self::model_aws_logs_services_response::AWSLogsServicesResponse;
 pub mod model_aws_logs_services_response_data;

src/datadogV2/model/model_aws_integration_iam_permissions_response.rs

@@ -0,0 +1,96 @@
+// 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};
+
+/// AWS Integration IAM Permissions response body.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct AWSIntegrationIamPermissionsResponse {
+    /// AWS Integration IAM Permissions response data.
+    #[serde(rename = "data")]
+    pub data: crate::datadogV2::model::AWSIntegrationIamPermissionsResponseData,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl AWSIntegrationIamPermissionsResponse {
+    pub fn new(
+        data: crate::datadogV2::model::AWSIntegrationIamPermissionsResponseData,
+    ) -> AWSIntegrationIamPermissionsResponse {
+        AWSIntegrationIamPermissionsResponse {
+            data,
+            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 AWSIntegrationIamPermissionsResponse {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct AWSIntegrationIamPermissionsResponseVisitor;
+        impl<'a> Visitor<'a> for AWSIntegrationIamPermissionsResponseVisitor {
+            type Value = AWSIntegrationIamPermissionsResponse;
+
+            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 data: Option<
+                    crate::datadogV2::model::AWSIntegrationIamPermissionsResponseData,
+                > = 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() {
+                        "data" => {
+                            data = 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 data = data.ok_or_else(|| M::Error::missing_field("data"))?;
+
+                let content = AWSIntegrationIamPermissionsResponse {
+                    data,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(AWSIntegrationIamPermissionsResponseVisitor)
+    }
+}