Add OpenAPI spec for OAuth2 well-known sites endpoint (#1700)

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

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

.generator/schemas/v2/openapi.yaml

@@ -57840,6 +57840,59 @@ components:
         - id
         - type
       type: object
+    OAuth2WellKnownSitesAttributes:
+      description: Attributes containing the list of public OAuth2 sites.
+      properties:
+        sites:
+          description: Array of public OAuth2 site URLs for the environment.
+          example:
+            - datadoghq.com
+            - datadoghq.eu
+            - us5.datadoghq.com
+            - us3.datadoghq.com
+            - ap1.datadoghq.com
+            - ap2.datadoghq.com
+          items:
+            description: Public OAuth2 site URL.
+            example: app.datadoghq.com
+            type: string
+          type: array
+      required:
+        - sites
+      type: object
+    OAuth2WellKnownSitesData:
+      description: Data object containing OAuth2 well-known sites information.
+      properties:
+        attributes:
+          $ref: "#/components/schemas/OAuth2WellKnownSitesAttributes"
+        id:
+          description: Environment identifier.
+          example: prod
+          type: string
+        type:
+          $ref: "#/components/schemas/OAuth2WellKnownSitesEnvType"
+      required:
+        - id
+        - type
+        - attributes
+      type: object
+    OAuth2WellKnownSitesEnvType:
+      default: env
+      description: JSON:API resource type for OAuth2 well-known sites environment.
+      enum:
+        - env
+      example: env
+      type: string
+      x-enum-varnames:
+        - ENV
+    OAuth2WellKnownSitesResponse:
+      description: Response payload containing the list of public OAuth2 sites for discovery.
+      properties:
+        data:
+          $ref: "#/components/schemas/OAuth2WellKnownSitesData"
+      required:
+        - data
+      type: object
     OAuthClientRegistrationError:
       description: Error payload returned by OAuth2 dynamic client registration as defined by RFC 7591.
       properties:
@@ -142472,6 +142525,40 @@ paths:
       summary: Get all aggregated DNS traffic
       tags:
         - Cloud Network Monitoring
+  /api/v2/oauth2/.well-known/sites:
+    get:
+      description: Retrieve the list of public OAuth2 sites available for the current environment. This endpoint is used for OAuth2 discovery and returns sites where users can authenticate.
+      operationId: GetOAuth2WellKnownSites
+      responses:
+        "200":
+          content:
+            application/json:
+              examples:
+                default:
+                  value:
+                    data:
+                      attributes:
+                        sites:
+                          - datadoghq.com
+                          - datadoghq.eu
+                          - us5.datadoghq.com
+                          - us3.datadoghq.com
+                          - ap1.datadoghq.com
+                          - ap2.datadoghq.com
+                      id: prod
+                      type: env
+              schema:
+                $ref: "#/components/schemas/OAuth2WellKnownSitesResponse"
+          description: OK
+        "429":
+          $ref: "#/components/responses/TooManyRequestsResponse"
+      security: []
+      summary: Get OAuth2 well-known sites
+      tags:
+        - OAuth2 Client Public
+      x-unstable: |-
+        **Note**: This endpoint is in preview and is subject to change.
+        If you have any feedback, contact [Datadog support](https://docs.datadoghq.com/help/).
   /api/v2/oauth2/clients/{client_uuid}/scopes_restriction:
     delete:
       description: Delete the scopes restriction configured for the OAuth2 client.

src/datadog/configuration.rs

@@ -556,6 +556,7 @@ impl Default for Configuration {
             ),
             ("v2.validate_monitor_user_template".to_owned(), false),
             ("v2.delete_scopes_restriction".to_owned(), false),
+            ("v2.get_o_auth2_well_known_sites".to_owned(), false),
             ("v2.get_scopes_restriction".to_owned(), false),
             ("v2.register_o_auth_client".to_owned(), false),
             ("v2.upsert_scopes_restriction".to_owned(), false),

src/datadogV2/api/api_o_auth2_client_public.rs

@@ -20,6 +20,14 @@ pub enum DeleteScopesRestrictionError {
     UnknownValue(serde_json::Value),
 }
 
+/// GetOAuth2WellKnownSitesError is a struct for typed errors of method [`OAuth2ClientPublicAPI::get_o_auth2_well_known_sites`]
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum GetOAuth2WellKnownSitesError {
+    APIErrorResponse(crate::datadogV2::model::APIErrorResponse),
+    UnknownValue(serde_json::Value),
+}
+
 /// GetScopesRestrictionError is a struct for typed errors of method [`OAuth2ClientPublicAPI::get_scopes_restriction`]
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
@@ -221,6 +229,106 @@ impl OAuth2ClientPublicAPI {
         }
     }
 
+    /// Retrieve the list of public OAuth2 sites available for the current environment. This endpoint is used for OAuth2 discovery and returns sites where users can authenticate.
+    pub async fn get_o_auth2_well_known_sites(
+        &self,
+    ) -> Result<
+        crate::datadogV2::model::OAuth2WellKnownSitesResponse,
+        datadog::Error<GetOAuth2WellKnownSitesError>,
+    > {
+        match self.get_o_auth2_well_known_sites_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),
+        }
+    }
+
+    /// Retrieve the list of public OAuth2 sites available for the current environment. This endpoint is used for OAuth2 discovery and returns sites where users can authenticate.
+    pub async fn get_o_auth2_well_known_sites_with_http_info(
+        &self,
+    ) -> Result<
+        datadog::ResponseContent<crate::datadogV2::model::OAuth2WellKnownSitesResponse>,
+        datadog::Error<GetOAuth2WellKnownSitesError>,
+    > {
+        let local_configuration = &self.config;
+        let operation_id = "v2.get_o_auth2_well_known_sites";
+        if local_configuration.is_unstable_operation_enabled(operation_id) {
+            warn!("Using unstable operation {operation_id}");
+        } else {
+            let local_error = datadog::UnstableOperationDisabledError {
+                msg: "Operation 'v2.get_o_auth2_well_known_sites' is not enabled".to_string(),
+            };
+            return Err(datadog::Error::UnstableOperationDisabledError(local_error));
+        }
+
+        let local_client = &self.client;
+
+        let local_uri_str = format!(
+            "{}/api/v2/oauth2/.well-known/sites",
+            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
+
+        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::OAuth2WellKnownSitesResponse>(
+                &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<GetOAuth2WellKnownSitesError> =
+                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 the scopes restriction configured for the OAuth2 client.
     pub async fn get_scopes_restriction(
         &self,

src/datadogV2/model/mod.rs

@@ -6380,6 +6380,14 @@ pub mod model_dns_metric_key;
 pub use self::model_dns_metric_key::DnsMetricKey;
 pub mod model_single_aggregated_dns_response_data_type;
 pub use self::model_single_aggregated_dns_response_data_type::SingleAggregatedDnsResponseDataType;
+pub mod model_o_auth2_well_known_sites_response;
+pub use self::model_o_auth2_well_known_sites_response::OAuth2WellKnownSitesResponse;
+pub mod model_o_auth2_well_known_sites_data;
+pub use self::model_o_auth2_well_known_sites_data::OAuth2WellKnownSitesData;
+pub mod model_o_auth2_well_known_sites_attributes;
+pub use self::model_o_auth2_well_known_sites_attributes::OAuth2WellKnownSitesAttributes;
+pub mod model_o_auth2_well_known_sites_env_type;
+pub use self::model_o_auth2_well_known_sites_env_type::OAuth2WellKnownSitesEnvType;
 pub mod model_o_auth_scopes_restriction_response;
 pub use self::model_o_auth_scopes_restriction_response::OAuthScopesRestrictionResponse;
 pub mod model_o_auth_scopes_restriction_response_data;

src/datadogV2/model/model_o_auth2_well_known_sites_attributes.rs

@@ -0,0 +1,92 @@
+// 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 containing the list of public OAuth2 sites.
+#[non_exhaustive]
+#[skip_serializing_none]
+#[derive(Clone, Debug, PartialEq, Serialize)]
+pub struct OAuth2WellKnownSitesAttributes {
+    /// Array of public OAuth2 site URLs for the environment.
+    #[serde(rename = "sites")]
+    pub sites: Vec<String>,
+    #[serde(flatten)]
+    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
+    #[serde(skip)]
+    #[serde(default)]
+    pub(crate) _unparsed: bool,
+}
+
+impl OAuth2WellKnownSitesAttributes {
+    pub fn new(sites: Vec<String>) -> OAuth2WellKnownSitesAttributes {
+        OAuth2WellKnownSitesAttributes {
+            sites,
+            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 OAuth2WellKnownSitesAttributes {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct OAuth2WellKnownSitesAttributesVisitor;
+        impl<'a> Visitor<'a> for OAuth2WellKnownSitesAttributesVisitor {
+            type Value = OAuth2WellKnownSitesAttributes;
+
+            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 sites: Option<Vec<String>> = 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() {
+                        "sites" => {
+                            sites = 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 sites = sites.ok_or_else(|| M::Error::missing_field("sites"))?;
+
+                let content = OAuth2WellKnownSitesAttributes {
+                    sites,
+                    additional_properties,
+                    _unparsed,
+                };
+
+                Ok(content)
+            }
+        }
+
+        deserializer.deserialize_any(OAuth2WellKnownSitesAttributesVisitor)
+    }
+}