Regenerate client from commit 5371379 of spec repo (#4476)

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

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

.generator/schemas/v2/openapi.yaml

@@ -0,0 +1,18 @@
+/**
+ * List governance insights returns "OK" response
+ */
+
+import { client, v2 } from "@datadog/datadog-api-client";
+
+const configuration = client.createConfiguration();
+configuration.unstableOperations["v2.listGovernanceInsights"] = true;
+const apiInstance = new v2.GovernanceInsightsApi(configuration);
+
+apiInstance
+  .listGovernanceInsights()
+  .then((data: v2.GovernanceInsightsResponse) => {
+    console.log(
+      "API called successfully. Returned data: " + JSON.stringify(data)
+    );
+  })
+  .catch((error: any) => console.error(error));

examples/v2/governance-insights/ListGovernanceInsights.ts

@@ -9359,6 +9359,21 @@ export const ScenariosModelMappings: {[key: string]: {[key: string]: any}} = {
             },
         "operationResponseType": "SAMLConfigurationResponse",
     },
+    "v2.ListGovernanceInsights": {
+        "withValues": {
+            "type": "boolean",
+            "format": "",
+            },
+        "orgUuid": {
+            "type": "string",
+            "format": "",
+            },
+        "filterProduct": {
+            "type": "Array<string>",
+            "format": "",
+            },
+        "operationResponseType": "GovernanceInsightsResponse",
+    },
     "v2.GetHamrOrgConnection": {
         "operationResponseType": "HamrOrgConnectionResponse",
     },

features/support/scenarios_model_mapping.ts

@@ -0,0 +1,24 @@
+@endpoint(governance-insights) @endpoint(governance-insights-v2)
+Feature: Governance Insights
+  Governance Insights surface key usage, configuration, and best-practice
+  signals for an organization within the Governance Console. Each insight
+  reports a current value (and, optionally, a previous value for comparison)
+  along with the query used to compute it, so that the Console can render
+  trends and highlight areas that need attention.
+
+  Background:
+    Given a valid "apiKeyAuth" key in the system
+    And a valid "appKeyAuth" key in the system
+    And an instance of "GovernanceInsights" API
+    And operation "ListGovernanceInsights" enabled
+    And new "ListGovernanceInsights" request
+
+  @generated @skip @team:DataDog/aaa-governance-console
+  Scenario: List governance insights returns "Bad Request" response
+    When the request is sent
+    Then the response status is 400 Bad Request
+
+  @generated @skip @team:DataDog/aaa-governance-console
+  Scenario: List governance insights returns "OK" response
+    When the request is sent
+    Then the response status is 200 OK

features/v2/governance_insights.feature

@@ -2762,6 +2762,12 @@
       "type": "safe"
     }
   },
+  "ListGovernanceInsights": {
+    "tag": "Governance Insights",
+    "undo": {
+      "type": "safe"
+    }
+  },
   "GetHamrOrgConnection": {
     "tag": "High Availability MultiRegion",
     "undo": {

features/v2/undo.json

@@ -501,6 +501,7 @@ export function createConfiguration(
       "v2.upsertAndPublishFormVersion": false,
       "v2.upsertFormVersion": false,
       "v2.updateOrgSamlConfigurations": false,
+      "v2.listGovernanceInsights": false,
       "v2.createHamrOrgConnection": false,
       "v2.getHamrOrgConnection": false,
       "v2.deleteEntityIntegrationConfig": false,

packages/datadog-api-client-common/configuration.ts

@@ -0,0 +1,229 @@
+import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi";
+import {
+  Configuration,
+  applySecurityAuthentication,
+} from "../../datadog-api-client-common/configuration";
+import {
+  RequestContext,
+  HttpMethod,
+  ResponseContext,
+} from "../../datadog-api-client-common/http/http";
+
+import { logger } from "../../../logger";
+import { ObjectSerializer } from "../models/ObjectSerializer";
+import { ApiException } from "../../datadog-api-client-common/exception";
+
+import { APIErrorResponse } from "../models/APIErrorResponse";
+import { GovernanceInsightsResponse } from "../models/GovernanceInsightsResponse";
+import { JSONAPIErrorResponse } from "../models/JSONAPIErrorResponse";
+
+export class GovernanceInsightsApiRequestFactory extends BaseAPIRequestFactory {
+  public async listGovernanceInsights(
+    withValues?: boolean,
+    orgUuid?: string,
+    filterProduct?: Array<string>,
+    _options?: Configuration
+  ): Promise<RequestContext> {
+    const _config = _options || this.configuration;
+
+    logger.warn("Using unstable operation 'listGovernanceInsights'");
+    if (!_config.unstableOperations["v2.listGovernanceInsights"]) {
+      throw new Error(
+        "Unstable operation 'listGovernanceInsights' is disabled"
+      );
+    }
+
+    // Path Params
+    const localVarPath = "/api/v2/governance/insights";
+
+    // Make Request Context
+    const requestContext = _config
+      .getServer("v2.GovernanceInsightsApi.listGovernanceInsights")
+      .makeRequestContext(localVarPath, HttpMethod.GET);
+    requestContext.setHeaderParam("Accept", "application/json");
+    requestContext.setHttpConfig(_config.httpConfig);
+
+    // Query Params
+    if (withValues !== undefined) {
+      requestContext.setQueryParam(
+        "withValues",
+        ObjectSerializer.serialize(withValues, "boolean", ""),
+        ""
+      );
+    }
+    if (orgUuid !== undefined) {
+      requestContext.setQueryParam(
+        "orgUuid",
+        ObjectSerializer.serialize(orgUuid, "string", ""),
+        ""
+      );
+    }
+    if (filterProduct !== undefined) {
+      requestContext.setQueryParam(
+        "filter[product]",
+        ObjectSerializer.serialize(filterProduct, "Array<string>", ""),
+        "multi"
+      );
+    }
+
+    // Apply auth methods
+    applySecurityAuthentication(_config, requestContext, [
+      "apiKeyAuth",
+      "appKeyAuth",
+    ]);
+
+    return requestContext;
+  }
+}
+
+export class GovernanceInsightsApiResponseProcessor {
+  /**
+   * 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 listGovernanceInsights
+   * @throws ApiException if the response code was not in [200, 299]
+   */
+  public async listGovernanceInsights(
+    response: ResponseContext
+  ): Promise<GovernanceInsightsResponse> {
+    const contentType = ObjectSerializer.normalizeMediaType(
+      response.headers["content-type"]
+    );
+    if (response.httpStatusCode === 200) {
+      const body: GovernanceInsightsResponse = ObjectSerializer.deserialize(
+        ObjectSerializer.parse(await response.body.text(), contentType),
+        "GovernanceInsightsResponse"
+      ) as GovernanceInsightsResponse;
+      return body;
+    }
+    if (
+      response.httpStatusCode === 400 ||
+      response.httpStatusCode === 401 ||
+      response.httpStatusCode === 403
+    ) {
+      const bodyText = ObjectSerializer.parse(
+        await response.body.text(),
+        contentType
+      );
+      let body: JSONAPIErrorResponse;
+      try {
+        body = ObjectSerializer.deserialize(
+          bodyText,
+          "JSONAPIErrorResponse"
+        ) as JSONAPIErrorResponse;
+      } catch (error) {
+        logger.debug(`Got error deserializing error: ${error}`);
+        throw new ApiException<JSONAPIErrorResponse>(
+          response.httpStatusCode,
+          bodyText
+        );
+      }
+      throw new ApiException<JSONAPIErrorResponse>(
+        response.httpStatusCode,
+        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: GovernanceInsightsResponse = ObjectSerializer.deserialize(
+        ObjectSerializer.parse(await response.body.text(), contentType),
+        "GovernanceInsightsResponse",
+        ""
+      ) as GovernanceInsightsResponse;
+      return body;
+    }
+
+    const body = (await response.body.text()) || "";
+    throw new ApiException<string>(
+      response.httpStatusCode,
+      'Unknown API Status Code!\nBody: "' + body + '"'
+    );
+  }
+}
+
+export interface GovernanceInsightsApiListGovernanceInsightsRequest {
+  /**
+   * Whether to compute and include the current and previous value of each insight.
+   * Defaults to `false`, in which case only insight metadata is returned.
+   * @type boolean
+   */
+  withValues?: boolean;
+  /**
+   * The UUID of the organization to compute insights for. Defaults to the organization of
+   * the authenticated user. Used to retrieve insights for a child organization from a
+   * parent organization.
+   * @type string
+   */
+  orgUuid?: string;
+  /**
+   * Restrict the results to insights belonging to the given products. May be repeated to
+   * filter by multiple products. Matching is case-insensitive.
+   * @type Array<string>
+   */
+  filterProduct?: Array<string>;
+}
+
+export class GovernanceInsightsApi {
+  private requestFactory: GovernanceInsightsApiRequestFactory;
+  private responseProcessor: GovernanceInsightsApiResponseProcessor;
+  private configuration: Configuration;
+
+  public constructor(
+    configuration: Configuration,
+    requestFactory?: GovernanceInsightsApiRequestFactory,
+    responseProcessor?: GovernanceInsightsApiResponseProcessor
+  ) {
+    this.configuration = configuration;
+    this.requestFactory =
+      requestFactory || new GovernanceInsightsApiRequestFactory(configuration);
+    this.responseProcessor =
+      responseProcessor || new GovernanceInsightsApiResponseProcessor();
+  }
+
+  /**
+   * Retrieve the list of governance insights available to the organization. By default, only
+   * insight metadata is returned; pass `withValues=true` to also compute and include each
+   * insight's current and previous values. Insights can be filtered by product.
+   * @param param The request object
+   */
+  public listGovernanceInsights(
+    param: GovernanceInsightsApiListGovernanceInsightsRequest = {},
+    options?: Configuration
+  ): Promise<GovernanceInsightsResponse> {
+    const requestContextPromise = this.requestFactory.listGovernanceInsights(
+      param.withValues,
+      param.orgUuid,
+      param.filterProduct,
+      options
+    );
+    return requestContextPromise.then((requestContext) => {
+      return this.configuration.httpApi
+        .send(requestContext)
+        .then((responseContext) => {
+          return this.responseProcessor.listGovernanceInsights(responseContext);
+        });
+    });
+  }
+}

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

@@ -644,6 +644,11 @@ export {
   GoogleChatIntegrationApi,
 } from "./apis/GoogleChatIntegrationApi";
 
+export {
+  GovernanceInsightsApiListGovernanceInsightsRequest,
+  GovernanceInsightsApi,
+} from "./apis/GovernanceInsightsApi";
+
 export {
   HighAvailabilityMultiRegionApiCreateHamrOrgConnectionRequest,
   HighAvailabilityMultiRegionApi,
@@ -4117,6 +4122,19 @@ export { GoogleChatUpdateOrganizationHandleRequestAttributes } from "./models/Go
 export { GoogleChatUpdateOrganizationHandleRequestData } from "./models/GoogleChatUpdateOrganizationHandleRequestData";
 export { GoogleMeetConfigurationReference } from "./models/GoogleMeetConfigurationReference";
 export { GoogleMeetConfigurationReferenceData } from "./models/GoogleMeetConfigurationReferenceData";
+export { GovernanceBestPracticeDefinition } from "./models/GovernanceBestPracticeDefinition";
+export { GovernanceInsightAttributes } from "./models/GovernanceInsightAttributes";
+export { GovernanceInsightAuditCompute } from "./models/GovernanceInsightAuditCompute";
+export { GovernanceInsightAuditQuery } from "./models/GovernanceInsightAuditQuery";
+export { GovernanceInsightData } from "./models/GovernanceInsightData";
+export { GovernanceInsightEventCompute } from "./models/GovernanceInsightEventCompute";
+export { GovernanceInsightEventQuery } from "./models/GovernanceInsightEventQuery";
+export { GovernanceInsightMetricQuery } from "./models/GovernanceInsightMetricQuery";
+export { GovernanceInsightPercentageQuery } from "./models/GovernanceInsightPercentageQuery";
+export { GovernanceInsightQueryConfig } from "./models/GovernanceInsightQueryConfig";
+export { GovernanceInsightResourceType } from "./models/GovernanceInsightResourceType";
+export { GovernanceInsightsResponse } from "./models/GovernanceInsightsResponse";
+export { GovernanceInsightUsageQuery } from "./models/GovernanceInsightUsageQuery";
 export { GreyNoiseAPIKey } from "./models/GreyNoiseAPIKey";
 export { GreyNoiseAPIKeyType } from "./models/GreyNoiseAPIKeyType";
 export { GreyNoiseAPIKeyUpdate } from "./models/GreyNoiseAPIKeyUpdate";