From fb4d3ec6e605bc6b6c585e2f01be744cbf614879 Mon Sep 17 00:00:00 2001 From: "ci.datadog-api-spec" Date: Mon, 20 Jul 2026 16:30:55 +0000 Subject: [PATCH] Regenerate client from commit 69667b8 of spec repo --- .generator/schemas/v2/openapi.yaml | 81 +++++++++ ...ginOrgConfigsMcpCrossAppAccessIssuerUrl.rs | 30 ++++ src/datadog/configuration.rs | 4 + src/datadogV2/api/api_organizations.rs | 164 ++++++++++++++++++ src/datadogV2/model/mod.rs | 8 + ...el_mcp_cross_app_access_issuer_url_type.rs | 48 +++++ ...app_access_issuer_url_update_attributes.rs | 94 ++++++++++ ...cross_app_access_issuer_url_update_data.rs | 116 +++++++++++++ ...ss_app_access_issuer_url_update_request.rs | 96 ++++++++++ .../features/v2/organizations.feature | 16 ++ tests/scenarios/features/v2/undo.json | 6 + tests/scenarios/function_mappings.rs | 34 ++++ 12 files changed, 697 insertions(+) create mode 100644 examples/v2_organizations_UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl.rs create mode 100644 src/datadogV2/model/model_mcp_cross_app_access_issuer_url_type.rs create mode 100644 src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_attributes.rs create mode 100644 src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_data.rs create mode 100644 src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_request.rs diff --git a/.generator/schemas/v2/openapi.yaml b/.generator/schemas/v2/openapi.yaml index ed984a56d..8fb6d8849 100644 --- a/.generator/schemas/v2/openapi.yaml +++ b/.generator/schemas/v2/openapi.yaml @@ -60208,6 +60208,41 @@ components: $ref: "#/components/schemas/MaxSessionDurationUpdateData" required: [data] type: object + McpCrossAppAccessIssuerUrlType: + description: Data type of an MCP Cross-App Access issuer URL update. + enum: [org_config] + example: org_config + type: string + x-enum-varnames: + - ORG_CONFIG + McpCrossAppAccessIssuerUrlUpdateAttributes: + description: Attributes for the MCP Cross-App Access issuer URL update request. + properties: + issuer_url: + description: |- + The Okta OIDC issuer URL for MCP Cross-App Access, for example + `https://your-subdomain.okta.com`. Provide an empty string to unset + the issuer URL and opt the organization out of MCP Cross-App Access. + example: https://your-subdomain.okta.com + type: string + required: [issuer_url] + type: object + McpCrossAppAccessIssuerUrlUpdateData: + description: The data object for an MCP Cross-App Access issuer URL update request. + properties: + attributes: + $ref: "#/components/schemas/McpCrossAppAccessIssuerUrlUpdateAttributes" + type: + $ref: "#/components/schemas/McpCrossAppAccessIssuerUrlType" + required: [type, attributes] + type: object + McpCrossAppAccessIssuerUrlUpdateRequest: + description: A request to update the MCP Cross-App Access issuer URL for an organization. + properties: + data: + $ref: "#/components/schemas/McpCrossAppAccessIssuerUrlUpdateData" + required: [data] + type: object McpScanRequest: description: The top-level request object for submitting an MCP SCA dependency scan. properties: @@ -154159,6 +154194,52 @@ paths: operator: OR permissions: - org_management + /api/v2/login/org_configs/mcp_cross_app_access_issuer_url: + put: + description: |- + Update the Okta OIDC issuer URL used for MCP Cross-App Access (XAA) + for the current organization. The URL must be a bare Okta issuer such + as `https://your-subdomain.okta.com` (no path, port, query, or fragment). + Provide an empty string to unset the issuer URL and opt the organization + out of MCP Cross-App Access. + operationId: UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl + requestBody: + content: + application/json: + examples: + default: + value: + data: + attributes: + issuer_url: https://your-subdomain.okta.com + type: org_config + schema: + $ref: "#/components/schemas/McpCrossAppAccessIssuerUrlUpdateRequest" + required: true + responses: + "204": + description: No Content + "400": + $ref: "#/components/responses/BadRequestResponse" + "401": + $ref: "#/components/responses/UnauthorizedResponse" + "403": + $ref: "#/components/responses/ForbiddenResponse" + "429": + $ref: "#/components/responses/TooManyRequestsResponse" + security: + - apiKeyAuth: [] + appKeyAuth: [] + - AuthZ: + - org_management + summary: Update the MCP Cross-App Access issuer URL + tags: [Organizations] + "x-permission": + operator: OR + permissions: + - org_management + x-unstable: |- + **Note**: This endpoint is in Preview and may change in the future. It is not yet recommended for production use. /api/v2/logs: post: description: |- diff --git a/examples/v2_organizations_UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl.rs b/examples/v2_organizations_UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl.rs new file mode 100644 index 000000000..b4f54429f --- /dev/null +++ b/examples/v2_organizations_UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl.rs @@ -0,0 +1,30 @@ +// Update the MCP Cross-App Access issuer URL returns "No Content" response +use datadog_api_client::datadog; +use datadog_api_client::datadogV2::api_organizations::OrganizationsAPI; +use datadog_api_client::datadogV2::model::McpCrossAppAccessIssuerUrlType; +use datadog_api_client::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateAttributes; +use datadog_api_client::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateData; +use datadog_api_client::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateRequest; + +#[tokio::main] +async fn main() { + let body = + McpCrossAppAccessIssuerUrlUpdateRequest::new(McpCrossAppAccessIssuerUrlUpdateData::new( + McpCrossAppAccessIssuerUrlUpdateAttributes::new( + "https://your-subdomain.okta.com".to_string(), + ), + McpCrossAppAccessIssuerUrlType::ORG_CONFIG, + )); + let mut configuration = datadog::Configuration::new(); + configuration + .set_unstable_operation_enabled("v2.UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl", true); + let api = OrganizationsAPI::with_config(configuration); + let resp = api + .update_login_org_configs_mcp_cross_app_access_issuer_url(body) + .await; + if let Ok(value) = resp { + println!("{:#?}", value); + } else { + println!("{:#?}", resp.unwrap_err()); + } +} diff --git a/src/datadog/configuration.rs b/src/datadog/configuration.rs index 0f430b0dd..1830838fc 100644 --- a/src/datadog/configuration.rs +++ b/src/datadog/configuration.rs @@ -575,6 +575,10 @@ impl Default for Configuration { ("v2.update_form".to_owned(), false), ("v2.upsert_and_publish_form_version".to_owned(), false), ("v2.upsert_form_version".to_owned(), false), + ( + "v2.update_login_org_configs_mcp_cross_app_access_issuer_url".to_owned(), + false, + ), ("v2.update_org_saml_configurations".to_owned(), false), ("v2.get_governance_control".to_owned(), false), ("v2.list_governance_controls".to_owned(), false), diff --git a/src/datadogV2/api/api_organizations.rs b/src/datadogV2/api/api_organizations.rs index cebe3256a..b48426fcf 100644 --- a/src/datadogV2/api/api_organizations.rs +++ b/src/datadogV2/api/api_organizations.rs @@ -126,6 +126,14 @@ pub enum UpdateLoginOrgConfigsMaxSessionDurationError { UnknownValue(serde_json::Value), } +/// UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrlError is a struct for typed errors of method [`OrganizationsAPI::update_login_org_configs_mcp_cross_app_access_issuer_url`] +#[derive(Debug, Clone, Serialize, Deserialize)] +#[serde(untagged)] +pub enum UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrlError { + APIErrorResponse(crate::datadogV2::model::APIErrorResponse), + UnknownValue(serde_json::Value), +} + /// UpdateOrgConfigError is a struct for typed errors of method [`OrganizationsAPI::update_org_config`] #[derive(Debug, Clone, Serialize, Deserialize)] #[serde(untagged)] @@ -1074,6 +1082,162 @@ impl OrganizationsAPI { } } + /// Update the Okta OIDC issuer URL used for MCP Cross-App Access (XAA) + /// for the current organization. The URL must be a bare Okta issuer such + /// as ` (no path, port, query, or fragment). + /// Provide an empty string to unset the issuer URL and opt the organization + /// out of MCP Cross-App Access. + pub async fn update_login_org_configs_mcp_cross_app_access_issuer_url( + &self, + body: crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateRequest, + ) -> Result<(), datadog::Error> { + match self + .update_login_org_configs_mcp_cross_app_access_issuer_url_with_http_info(body) + .await + { + Ok(_) => Ok(()), + Err(err) => Err(err), + } + } + + /// Update the Okta OIDC issuer URL used for MCP Cross-App Access (XAA) + /// for the current organization. The URL must be a bare Okta issuer such + /// as ` (no path, port, query, or fragment). + /// Provide an empty string to unset the issuer URL and opt the organization + /// out of MCP Cross-App Access. + pub async fn update_login_org_configs_mcp_cross_app_access_issuer_url_with_http_info( + &self, + body: crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateRequest, + ) -> Result< + datadog::ResponseContent<()>, + datadog::Error, + > { + let local_configuration = &self.config; + let operation_id = "v2.update_login_org_configs_mcp_cross_app_access_issuer_url"; + if local_configuration.is_unstable_operation_enabled(operation_id) { + warn!("Using unstable operation {operation_id}"); + } else { + let local_error = datadog::UnstableOperationDisabledError { + msg: "Operation 'v2.update_login_org_configs_mcp_cross_app_access_issuer_url' is not enabled".to_string(), + }; + return Err(datadog::Error::UnstableOperationDisabledError(local_error)); + } + + let local_client = &self.client; + + let local_uri_str = format!( + "{}/api/v2/login/org_configs/mcp_cross_app_access_issuer_url", + local_configuration.get_operation_host(operation_id) + ); + let mut local_req_builder = + local_client.request(reqwest::Method::PUT, local_uri_str.as_str()); + + // build headers + let mut headers = HeaderMap::new(); + headers.insert("Content-Type", HeaderValue::from_static("application/json")); + headers.insert("Accept", HeaderValue::from_static("*/*")); + + // 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"), + ); + }; + + // build body parameters + let output = Vec::new(); + let mut ser = serde_json::Serializer::with_formatter(output, datadog::DDFormatter); + if body.serialize(&mut ser).is_ok() { + if let Some(content_encoding) = headers.get("Content-Encoding") { + match content_encoding.to_str().unwrap_or_default() { + "gzip" => { + let mut enc = GzEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + "deflate" => { + let mut enc = ZlibEncoder::new(Vec::new(), Compression::default()); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + #[cfg(feature = "zstd")] + "zstd1" => { + let mut enc = zstd::stream::Encoder::new(Vec::new(), 0).unwrap(); + let _ = enc.write_all(ser.into_inner().as_slice()); + match enc.finish() { + Ok(buf) => { + local_req_builder = local_req_builder.body(buf); + } + Err(e) => return Err(datadog::Error::Io(e)), + } + } + _ => { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + } else { + local_req_builder = local_req_builder.body(ser.into_inner()); + } + } + + 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() { + Ok(datadog::ResponseContent { + status: local_status, + content: local_content, + entity: None, + }) + } else { + let local_entity: Option = + 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)) + } + } + /// Update the value of a specific Org Config. pub async fn update_org_config( &self, diff --git a/src/datadogV2/model/mod.rs b/src/datadogV2/model/mod.rs index 448df5bc7..930ddab4f 100644 --- a/src/datadogV2/model/mod.rs +++ b/src/datadogV2/model/mod.rs @@ -6338,6 +6338,14 @@ pub mod model_max_session_duration_update_attributes; pub use self::model_max_session_duration_update_attributes::MaxSessionDurationUpdateAttributes; pub mod model_max_session_duration_type; pub use self::model_max_session_duration_type::MaxSessionDurationType; +pub mod model_mcp_cross_app_access_issuer_url_update_request; +pub use self::model_mcp_cross_app_access_issuer_url_update_request::McpCrossAppAccessIssuerUrlUpdateRequest; +pub mod model_mcp_cross_app_access_issuer_url_update_data; +pub use self::model_mcp_cross_app_access_issuer_url_update_data::McpCrossAppAccessIssuerUrlUpdateData; +pub mod model_mcp_cross_app_access_issuer_url_update_attributes; +pub use self::model_mcp_cross_app_access_issuer_url_update_attributes::McpCrossAppAccessIssuerUrlUpdateAttributes; +pub mod model_mcp_cross_app_access_issuer_url_type; +pub use self::model_mcp_cross_app_access_issuer_url_type::McpCrossAppAccessIssuerUrlType; pub mod model_content_encoding; pub use self::model_content_encoding::ContentEncoding; pub mod model_http_log_item; diff --git a/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_type.rs b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_type.rs new file mode 100644 index 000000000..7cd9d2d2e --- /dev/null +++ b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_type.rs @@ -0,0 +1,48 @@ +// 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::{Deserialize, Deserializer, Serialize, Serializer}; + +#[non_exhaustive] +#[derive(Clone, Debug, Eq, PartialEq)] +pub enum McpCrossAppAccessIssuerUrlType { + ORG_CONFIG, + UnparsedObject(crate::datadog::UnparsedObject), +} + +impl ToString for McpCrossAppAccessIssuerUrlType { + fn to_string(&self) -> String { + match self { + Self::ORG_CONFIG => String::from("org_config"), + Self::UnparsedObject(v) => v.value.to_string(), + } + } +} + +impl Serialize for McpCrossAppAccessIssuerUrlType { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + match self { + Self::UnparsedObject(v) => v.serialize(serializer), + _ => serializer.serialize_str(self.to_string().as_str()), + } + } +} + +impl<'de> Deserialize<'de> for McpCrossAppAccessIssuerUrlType { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let s: String = String::deserialize(deserializer)?; + Ok(match s.as_str() { + "org_config" => Self::ORG_CONFIG, + _ => Self::UnparsedObject(crate::datadog::UnparsedObject { + value: serde_json::Value::String(s.into()), + }), + }) + } +} diff --git a/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_attributes.rs b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_attributes.rs new file mode 100644 index 000000000..d8767e51b --- /dev/null +++ b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_attributes.rs @@ -0,0 +1,94 @@ +// 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 for the MCP Cross-App Access issuer URL update request. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct McpCrossAppAccessIssuerUrlUpdateAttributes { + /// The Okta OIDC issuer URL for MCP Cross-App Access, for example + /// ` Provide an empty string to unset + /// the issuer URL and opt the organization out of MCP Cross-App Access. + #[serde(rename = "issuer_url")] + pub issuer_url: String, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl McpCrossAppAccessIssuerUrlUpdateAttributes { + pub fn new(issuer_url: String) -> McpCrossAppAccessIssuerUrlUpdateAttributes { + McpCrossAppAccessIssuerUrlUpdateAttributes { + issuer_url, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for McpCrossAppAccessIssuerUrlUpdateAttributes { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct McpCrossAppAccessIssuerUrlUpdateAttributesVisitor; + impl<'a> Visitor<'a> for McpCrossAppAccessIssuerUrlUpdateAttributesVisitor { + type Value = McpCrossAppAccessIssuerUrlUpdateAttributes; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut issuer_url: Option = 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::()? { + match k.as_str() { + "issuer_url" => { + issuer_url = 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 issuer_url = issuer_url.ok_or_else(|| M::Error::missing_field("issuer_url"))?; + + let content = McpCrossAppAccessIssuerUrlUpdateAttributes { + issuer_url, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(McpCrossAppAccessIssuerUrlUpdateAttributesVisitor) + } +} diff --git a/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_data.rs b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_data.rs new file mode 100644 index 000000000..047eb364e --- /dev/null +++ b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_data.rs @@ -0,0 +1,116 @@ +// 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 data object for an MCP Cross-App Access issuer URL update request. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct McpCrossAppAccessIssuerUrlUpdateData { + /// Attributes for the MCP Cross-App Access issuer URL update request. + #[serde(rename = "attributes")] + pub attributes: crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateAttributes, + /// Data type of an MCP Cross-App Access issuer URL update. + #[serde(rename = "type")] + pub type_: crate::datadogV2::model::McpCrossAppAccessIssuerUrlType, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl McpCrossAppAccessIssuerUrlUpdateData { + pub fn new( + attributes: crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateAttributes, + type_: crate::datadogV2::model::McpCrossAppAccessIssuerUrlType, + ) -> McpCrossAppAccessIssuerUrlUpdateData { + McpCrossAppAccessIssuerUrlUpdateData { + attributes, + type_, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for McpCrossAppAccessIssuerUrlUpdateData { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct McpCrossAppAccessIssuerUrlUpdateDataVisitor; + impl<'a> Visitor<'a> for McpCrossAppAccessIssuerUrlUpdateDataVisitor { + type Value = McpCrossAppAccessIssuerUrlUpdateData; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut attributes: Option< + crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateAttributes, + > = None; + let mut type_: Option = + 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::()? { + match k.as_str() { + "attributes" => { + attributes = 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::McpCrossAppAccessIssuerUrlType::UnparsedObject(_type_) => { + _unparsed = true; + }, + _ => {} + } + } + } + &_ => { + if let Ok(value) = serde_json::from_value(v.clone()) { + additional_properties.insert(k, value); + } + } + } + } + let attributes = attributes.ok_or_else(|| M::Error::missing_field("attributes"))?; + let type_ = type_.ok_or_else(|| M::Error::missing_field("type_"))?; + + let content = McpCrossAppAccessIssuerUrlUpdateData { + attributes, + type_, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(McpCrossAppAccessIssuerUrlUpdateDataVisitor) + } +} diff --git a/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_request.rs b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_request.rs new file mode 100644 index 000000000..60b30a8d4 --- /dev/null +++ b/src/datadogV2/model/model_mcp_cross_app_access_issuer_url_update_request.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}; + +/// A request to update the MCP Cross-App Access issuer URL for an organization. +#[non_exhaustive] +#[skip_serializing_none] +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct McpCrossAppAccessIssuerUrlUpdateRequest { + /// The data object for an MCP Cross-App Access issuer URL update request. + #[serde(rename = "data")] + pub data: crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateData, + #[serde(flatten)] + pub additional_properties: std::collections::BTreeMap, + #[serde(skip)] + #[serde(default)] + pub(crate) _unparsed: bool, +} + +impl McpCrossAppAccessIssuerUrlUpdateRequest { + pub fn new( + data: crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateData, + ) -> McpCrossAppAccessIssuerUrlUpdateRequest { + McpCrossAppAccessIssuerUrlUpdateRequest { + data, + additional_properties: std::collections::BTreeMap::new(), + _unparsed: false, + } + } + + pub fn additional_properties( + mut self, + value: std::collections::BTreeMap, + ) -> Self { + self.additional_properties = value; + self + } +} + +impl<'de> Deserialize<'de> for McpCrossAppAccessIssuerUrlUpdateRequest { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + struct McpCrossAppAccessIssuerUrlUpdateRequestVisitor; + impl<'a> Visitor<'a> for McpCrossAppAccessIssuerUrlUpdateRequestVisitor { + type Value = McpCrossAppAccessIssuerUrlUpdateRequest; + + fn expecting(&self, f: &mut Formatter<'_>) -> fmt::Result { + f.write_str("a mapping") + } + + fn visit_map(self, mut map: M) -> Result + where + M: MapAccess<'a>, + { + let mut data: Option< + crate::datadogV2::model::McpCrossAppAccessIssuerUrlUpdateData, + > = 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::()? { + 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 = McpCrossAppAccessIssuerUrlUpdateRequest { + data, + additional_properties, + _unparsed, + }; + + Ok(content) + } + } + + deserializer.deserialize_any(McpCrossAppAccessIssuerUrlUpdateRequestVisitor) + } +} diff --git a/tests/scenarios/features/v2/organizations.feature b/tests/scenarios/features/v2/organizations.feature index a8ed63ab7..844e415f7 100644 --- a/tests/scenarios/features/v2/organizations.feature +++ b/tests/scenarios/features/v2/organizations.feature @@ -168,6 +168,22 @@ Feature: Organizations When the request is sent Then the response status is 404 Not Found + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Update the MCP Cross-App Access issuer URL returns "Bad Request" response + Given operation "UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl" enabled + And new "UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl" request + And body with value {"data": {"attributes": {"issuer_url": "https://your-subdomain.okta.com"}, "type": "org_config"}} + When the request is sent + Then the response status is 400 Bad Request + + @generated @skip @team:DataDog/delegated-auth-login + Scenario: Update the MCP Cross-App Access issuer URL returns "No Content" response + Given operation "UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl" enabled + And new "UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl" request + And body with value {"data": {"attributes": {"issuer_url": "https://your-subdomain.okta.com"}, "type": "org_config"}} + When the request is sent + Then the response status is 204 No Content + @generated @skip @team:DataDog/delegated-auth-login Scenario: Update the maximum session duration returns "Bad Request" response Given new "UpdateLoginOrgConfigsMaxSessionDuration" request diff --git a/tests/scenarios/features/v2/undo.json b/tests/scenarios/features/v2/undo.json index f7316aecd..ea34cd761 100644 --- a/tests/scenarios/features/v2/undo.json +++ b/tests/scenarios/features/v2/undo.json @@ -4768,6 +4768,12 @@ "type": "idempotent" } }, + "UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl": { + "tag": "Organizations", + "undo": { + "type": "idempotent" + } + }, "SubmitLog": { "tag": "Logs", "undo": { diff --git a/tests/scenarios/function_mappings.rs b/tests/scenarios/function_mappings.rs index 9732c15b3..f04f2f767 100644 --- a/tests/scenarios/function_mappings.rs +++ b/tests/scenarios/function_mappings.rs @@ -4878,6 +4878,10 @@ pub fn collect_function_calls(world: &mut DatadogWorld) { "v2.UpdateLoginOrgConfigsMaxSessionDuration".into(), test_v2_update_login_org_configs_max_session_duration, ); + world.function_mappings.insert( + "v2.UpdateLoginOrgConfigsMcpCrossAppAccessIssuerUrl".into(), + test_v2_update_login_org_configs_mcp_cross_app_access_issuer_url, + ); world .function_mappings .insert("v2.ListOrgs".into(), test_v2_list_orgs); @@ -37331,6 +37335,36 @@ fn test_v2_update_login_org_configs_max_session_duration( world.response.code = response.status.as_u16(); } +fn test_v2_update_login_org_configs_mcp_cross_app_access_issuer_url( + world: &mut DatadogWorld, + _parameters: &HashMap, +) { + let api = world + .api_instances + .v2_api_organizations + .as_ref() + .expect("api instance not found"); + let body = serde_json::from_value(_parameters.get("body").unwrap().clone()).unwrap(); + let response = match block_on( + api.update_login_org_configs_mcp_cross_app_access_issuer_url_with_http_info(body), + ) { + Ok(response) => response, + Err(error) => { + return match error { + Error::ResponseError(e) => { + world.response.code = e.status.as_u16(); + if let Some(entity) = e.entity { + world.response.object = serde_json::to_value(entity).unwrap(); + } + } + _ => panic!("error parsing response: {error}"), + }; + } + }; + world.response.object = serde_json::to_value(response.entity).unwrap(); + world.response.code = response.status.as_u16(); +} + fn test_v2_list_orgs(world: &mut DatadogWorld, _parameters: &HashMap) { let api = world .api_instances