Regenerate client from commit de2517ad of spec repo (#2451)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-02 12:38:45.919876",
-            "spec_repo_commit": "4fd1c189"
+            "regenerated": "2025-07-02 16:34:51.190107",
+            "spec_repo_commit": "de2517ad"
         },
         "v2": {
             "apigentools_version": "1.6.6",
-            "regenerated": "2025-07-02 12:38:45.936124",
-            "spec_repo_commit": "4fd1c189"
+            "regenerated": "2025-07-02 16:34:51.206563",
+            "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.ts

@@ -0,0 +1,17 @@
+/**
+ * Get AWS integration IAM permissions returns "AWS IAM Permissions object" response
+ */
+
+import { client, v2 } from "@datadog/datadog-api-client";
+
+const configuration = client.createConfiguration();
+const apiInstance = new v2.AWSIntegrationApi(configuration);
+
+apiInstance
+  .getAWSIntegrationIAMPermissions()
+  .then((data: v2.AWSIntegrationIamPermissionsResponse) => {
+    console.log(
+      "API called successfully. Returned data: " + JSON.stringify(data)
+    );
+  })
+  .catch((error: any) => console.error(error));

features/support/scenarios_model_mapping.ts

@@ -5025,6 +5025,9 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = {
     "v2.CreateNewAWSExternalID": {
         "operationResponseType": "AWSNewExternalIDResponse",
     },
+    "v2.GetAWSIntegrationIAMPermissions": {
+        "operationResponseType": "AWSIntegrationIamPermissionsResponse",
+    },
     "v2.ListAWSLogsServices": {
         "operationResponseType": "AWSLogsServicesResponse",
     },

features/v2/aws_integration.feature

@@ -82,6 +82,12 @@ Feature: AWS Integration
     When the request is sent
     Then the response status is 200 AWS External ID object
 
+  @generated @skip @team:DataDog/aws-integrations
+  Scenario: Get AWS integration IAM permissions returns "AWS IAM Permissions object" response
+    Given new "GetAWSIntegrationIAMPermissions" request
+    When the request is sent
+    Then the response status is 200 AWS IAM Permissions object
+
   @team:DataDog/aws-integrations
   Scenario: Get an AWS integration by config ID returns "AWS Account object" response
     Given operation "GetAWSAccount" enabled

features/v2/undo.json

@@ -1214,6 +1214,12 @@
       "type": "safe"
     }
   },
+  "GetAWSIntegrationIAMPermissions": {
+    "tag": "AWS Integration",
+    "undo": {
+      "type": "safe"
+    }
+  },
   "ListAWSLogsServices": {
     "tag": "AWS Logs Integration",
     "undo": {

packages/datadog-api-client-v2/apis/AWSIntegrationApi.ts

@@ -21,6 +21,7 @@ import { AWSAccountCreateRequest } from "../models/AWSAccountCreateRequest";
 import { AWSAccountResponse } from "../models/AWSAccountResponse";
 import { AWSAccountsResponse } from "../models/AWSAccountsResponse";
 import { AWSAccountUpdateRequest } from "../models/AWSAccountUpdateRequest";
+import { AWSIntegrationIamPermissionsResponse } from "../models/AWSIntegrationIamPermissionsResponse";
 import { AWSNamespacesResponse } from "../models/AWSNamespacesResponse";
 import { AWSNewExternalIDResponse } from "../models/AWSNewExternalIDResponse";
 
@@ -180,6 +181,30 @@ export class AWSIntegrationApiRequestFactory extends BaseAPIRequestFactory {
     return requestContext;
   }
 
+  public async getAWSIntegrationIAMPermissions(
+    _options?: Configuration
+  ): Promise<RequestContext> {
+    const _config = _options || this.configuration;
+
+    // Path Params
+    const localVarPath = "/api/v2/integration/aws/iam_permissions";
+
+    // Make Request Context
+    const requestContext = _config
+      .getServer("v2.AWSIntegrationApi.getAWSIntegrationIAMPermissions")
+      .makeRequestContext(localVarPath, HttpMethod.GET);
+    requestContext.setHeaderParam("Accept", "application/json");
+    requestContext.setHttpConfig(_config.httpConfig);
+
+    // Apply auth methods
+    applySecurityAuthentication(_config, requestContext, [
+      "apiKeyAuth",
+      "appKeyAuth",
+    ]);
+
+    return requestContext;
+  }
+
   public async listAWSAccounts(
     awsAccountId?: string,
     _options?: Configuration
@@ -547,6 +572,66 @@ export class AWSIntegrationApiResponseProcessor {
     );
   }
 
+  /**
+   * Unwraps the actual response sent by the server from the response context and deserializes the response content
+   * to the expected objects
+   *
+   * @params response Response returned by the server for a request to getAWSIntegrationIAMPermissions
+   * @throws ApiException if the response code was not in [200, 299]
+   */
+  public async getAWSIntegrationIAMPermissions(
+    response: ResponseContext
+  ): Promise<AWSIntegrationIamPermissionsResponse> {
+    const contentType = ObjectSerializer.normalizeMediaType(
+      response.headers["content-type"]
+    );
+    if (response.httpStatusCode === 200) {
+      const body: AWSIntegrationIamPermissionsResponse =
+        ObjectSerializer.deserialize(
+          ObjectSerializer.parse(await response.body.text(), contentType),
+          "AWSIntegrationIamPermissionsResponse"
+        ) as AWSIntegrationIamPermissionsResponse;
+      return body;
+    }
+    if (response.httpStatusCode === 429) {
+      const bodyText = ObjectSerializer.parse(
+        await response.body.text(),
+        contentType
+      );
+      let body: APIErrorResponse;
+      try {
+        body = ObjectSerializer.deserialize(
+          bodyText,
+          "APIErrorResponse"
+        ) as APIErrorResponse;
+      } catch (error) {
+        logger.debug(`Got error deserializing error: ${error}`);
+        throw new ApiException<APIErrorResponse>(
+          response.httpStatusCode,
+          bodyText
+        );
+      }
+      throw new ApiException<APIErrorResponse>(response.httpStatusCode, body);
+    }
+
+    // Work around for missing responses in specification, e.g. for petstore.yaml
+    if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
+      const body: AWSIntegrationIamPermissionsResponse =
+        ObjectSerializer.deserialize(
+          ObjectSerializer.parse(await response.body.text(), contentType),
+          "AWSIntegrationIamPermissionsResponse",
+          ""
+        ) as AWSIntegrationIamPermissionsResponse;
+      return body;
+    }
+
+    const body = (await response.body.text()) || "";
+    throw new ApiException<string>(
+      response.httpStatusCode,
+      'Unknown API Status Code!\nBody: "' + body + '"'
+    );
+  }
+
   /**
    * Unwraps the actual response sent by the server from the response context and deserializes the response content
    * to the expected objects
@@ -871,6 +956,26 @@ export class AWSIntegrationApi {
     });
   }
 
+  /**
+   * Get all AWS IAM permissions required for the AWS integration.
+   * @param param The request object
+   */
+  public getAWSIntegrationIAMPermissions(
+    options?: Configuration
+  ): Promise<AWSIntegrationIamPermissionsResponse> {
+    const requestContextPromise =
+      this.requestFactory.getAWSIntegrationIAMPermissions(options);
+    return requestContextPromise.then((requestContext) => {
+      return this.configuration.httpApi
+        .send(requestContext)
+        .then((responseContext) => {
+          return this.responseProcessor.getAWSIntegrationIAMPermissions(
+            responseContext
+          );
+        });
+    });
+  }
+
   /**
    * Get a list of AWS Account Integration Configs.
    * @param param The request object

packages/datadog-api-client-v2/index.ts

@@ -948,6 +948,10 @@ export { AwsCURConfigResponse } from "./models/AwsCURConfigResponse";
 export { AwsCURConfigsResponse } from "./models/AwsCURConfigsResponse";
 export { AwsCURConfigType } from "./models/AwsCURConfigType";
 export { AWSIntegration } from "./models/AWSIntegration";
+export { AWSIntegrationIamPermissionsResponse } from "./models/AWSIntegrationIamPermissionsResponse";
+export { AWSIntegrationIamPermissionsResponseAttributes } from "./models/AWSIntegrationIamPermissionsResponseAttributes";
+export { AWSIntegrationIamPermissionsResponseData } from "./models/AWSIntegrationIamPermissionsResponseData";
+export { AWSIntegrationIamPermissionsResponseDataType } from "./models/AWSIntegrationIamPermissionsResponseDataType";
 export { AWSIntegrationType } from "./models/AWSIntegrationType";
 export { AWSIntegrationUpdate } from "./models/AWSIntegrationUpdate";
 export { AWSLambdaForwarderConfig } from "./models/AWSLambdaForwarderConfig";

packages/datadog-api-client-v2/models/AWSIntegrationIamPermissionsResponse.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 2020-Present Datadog, Inc.
+ */
+import { AWSIntegrationIamPermissionsResponseData } from "./AWSIntegrationIamPermissionsResponseData";
+
+import { AttributeTypeMap } from "../../datadog-api-client-common/util";
+
+/**
+ * AWS Integration IAM Permissions response body.
+ */
+export class AWSIntegrationIamPermissionsResponse {
+  /**
+   * AWS Integration IAM Permissions response data.
+   */
+  "data": AWSIntegrationIamPermissionsResponseData;
+
+  /**
+   * A container for additional, undeclared properties.
+   * This is a holder for any undeclared properties as specified with
+   * the 'additionalProperties' keyword in the OAS document.
+   */
+  "additionalProperties"?: { [key: string]: any };
+
+  /**
+   * @ignore
+   */
+  "_unparsed"?: boolean;
+
+  /**
+   * @ignore
+   */
+  static readonly attributeTypeMap: AttributeTypeMap = {
+    data: {
+      baseName: "data",
+      type: "AWSIntegrationIamPermissionsResponseData",
+      required: true,
+    },
+    additionalProperties: {
+      baseName: "additionalProperties",
+      type: "any",
+    },
+  };
+
+  /**
+   * @ignore
+   */
+  static getAttributeTypeMap(): AttributeTypeMap {
+    return AWSIntegrationIamPermissionsResponse.attributeTypeMap;
+  }
+
+  public constructor() {}
+}