capo-devops-agent 0.1.0__py3-none-any.whl

capo_devops_agent/types/mcp_server_authorization_config.py

@@ -0,0 +1,138 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerAuthorizationConfig``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError, SerializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.mcp_server_api_key_config
+    import capo_devops_agent.types.mcp_server_authorization_discovery_config
+    import capo_devops_agent.types.mcp_server_bearer_token_config
+    import capo_devops_agent.types.mcp_server_o_auth3_lo_config
+    import capo_devops_agent.types.mcp_server_o_auth_client_credentials_config
+
+
+class _MCPServerAuthorizationConfig_oAuthClientCredentials(TypedDict, closed=True):
+    oAuthClientCredentials: "capo_devops_agent.types.mcp_server_o_auth_client_credentials_config.MCPServerOAuthClientCredentialsConfig"
+
+
+class _MCPServerAuthorizationConfig_oAuth3LO(TypedDict, closed=True):
+    oAuth3LO: (
+        "capo_devops_agent.types.mcp_server_o_auth3_lo_config.MCPServerOAuth3LOConfig"
+    )
+
+
+class _MCPServerAuthorizationConfig_apiKey(TypedDict, closed=True):
+    apiKey: "capo_devops_agent.types.mcp_server_api_key_config.MCPServerAPIKeyConfig"
+
+
+class _MCPServerAuthorizationConfig_bearerToken(TypedDict, closed=True):
+    bearerToken: "capo_devops_agent.types.mcp_server_bearer_token_config.MCPServerBearerTokenConfig"
+
+
+class _MCPServerAuthorizationConfig_authorizationDiscovery(TypedDict, closed=True):
+    authorizationDiscovery: "capo_devops_agent.types.mcp_server_authorization_discovery_config.MCPServerAuthorizationDiscoveryConfig"
+
+
+MCPServerAuthorizationConfig: TypeAlias = (
+    _MCPServerAuthorizationConfig_oAuthClientCredentials
+    | _MCPServerAuthorizationConfig_oAuth3LO
+    | _MCPServerAuthorizationConfig_apiKey
+    | _MCPServerAuthorizationConfig_bearerToken
+    | _MCPServerAuthorizationConfig_authorizationDiscovery
+)
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerAuthorizationConfig) -> dict:
+    if "oAuthClientCredentials" in value:
+        import capo_devops_agent.types.mcp_server_o_auth_client_credentials_config
+
+        return {
+            "oAuthClientCredentials": capo_devops_agent.types.mcp_server_o_auth_client_credentials_config.serialize_json(
+                value["oAuthClientCredentials"]
+            )
+        }
+    elif "oAuth3LO" in value:
+        import capo_devops_agent.types.mcp_server_o_auth3_lo_config
+
+        return {
+            "oAuth3LO": capo_devops_agent.types.mcp_server_o_auth3_lo_config.serialize_json(
+                value["oAuth3LO"]
+            )
+        }
+    elif "apiKey" in value:
+        import capo_devops_agent.types.mcp_server_api_key_config
+
+        return {
+            "apiKey": capo_devops_agent.types.mcp_server_api_key_config.serialize_json(
+                value["apiKey"]
+            )
+        }
+    elif "bearerToken" in value:
+        import capo_devops_agent.types.mcp_server_bearer_token_config
+
+        return {
+            "bearerToken": capo_devops_agent.types.mcp_server_bearer_token_config.serialize_json(
+                value["bearerToken"]
+            )
+        }
+    elif "authorizationDiscovery" in value:
+        import capo_devops_agent.types.mcp_server_authorization_discovery_config
+
+        return {
+            "authorizationDiscovery": capo_devops_agent.types.mcp_server_authorization_discovery_config.serialize_json(
+                value["authorizationDiscovery"]
+            )
+        }
+    else:
+        raise SerializationError("MCPServerAuthorizationConfig: no variant present")
+
+
+def deserialize_json(data: dict) -> MCPServerAuthorizationConfig:
+    if data.get("oAuthClientCredentials") is not None:
+        import capo_devops_agent.types.mcp_server_o_auth_client_credentials_config
+
+        return {
+            "oAuthClientCredentials": capo_devops_agent.types.mcp_server_o_auth_client_credentials_config.deserialize_json(
+                data["oAuthClientCredentials"]
+            )
+        }
+    elif data.get("oAuth3LO") is not None:
+        import capo_devops_agent.types.mcp_server_o_auth3_lo_config
+
+        return {
+            "oAuth3LO": capo_devops_agent.types.mcp_server_o_auth3_lo_config.deserialize_json(
+                data["oAuth3LO"]
+            )
+        }
+    elif data.get("apiKey") is not None:
+        import capo_devops_agent.types.mcp_server_api_key_config
+
+        return {
+            "apiKey": capo_devops_agent.types.mcp_server_api_key_config.deserialize_json(
+                data["apiKey"]
+            )
+        }
+    elif data.get("bearerToken") is not None:
+        import capo_devops_agent.types.mcp_server_bearer_token_config
+
+        return {
+            "bearerToken": capo_devops_agent.types.mcp_server_bearer_token_config.deserialize_json(
+                data["bearerToken"]
+            )
+        }
+    elif data.get("authorizationDiscovery") is not None:
+        import capo_devops_agent.types.mcp_server_authorization_discovery_config
+
+        return {
+            "authorizationDiscovery": capo_devops_agent.types.mcp_server_authorization_discovery_config.deserialize_json(
+                data["authorizationDiscovery"]
+            )
+        }
+    else:
+        raise DeserializationError(
+            "MCPServerAuthorizationConfig: no recognized variant key"
+        )

capo_devops_agent/types/mcp_server_authorization_discovery_config.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerAuthorizationDiscoveryConfig``."""
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class MCPServerAuthorizationDiscoveryConfig(TypedDict, closed=True):
+    return_to_endpoint: "str"
+    """<p>The endpoint to return to after OAuth flow completes (must be AWS console domain)</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerAuthorizationDiscoveryConfig) -> dict:
+    out: dict = {}
+    out["returnToEndpoint"] = value["return_to_endpoint"]
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerAuthorizationDiscoveryConfig:
+    out: MCPServerAuthorizationDiscoveryConfig = {}  # type: ignore[typeddict-item]
+    if data.get("returnToEndpoint") is not None:
+        out["return_to_endpoint"] = data["returnToEndpoint"]
+    else:
+        raise DeserializationError(
+            "MCPServerAuthorizationDiscoveryConfig.return_to_endpoint required"
+        )
+    return out

capo_devops_agent/types/mcp_server_authorization_method.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerAuthorizationMethod``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Supported authorization methods for MCP servers.</p>"""
+MCPServerAuthorizationMethod: TypeAlias = Literal[
+    "oauth-client-credentials",
+    "oauth-3lo",
+    "api-key",
+    "bearer-token",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerAuthorizationMethod) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> MCPServerAuthorizationMethod:
+    return cast(MCPServerAuthorizationMethod, data)

capo_devops_agent/types/mcp_server_bearer_token_config.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerBearerTokenConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.token_value
+
+
+class MCPServerBearerTokenConfig(TypedDict, closed=True):
+    token_name: "str"
+    """<p>User friendly bearer token name specified by end user.</p>"""
+    token_value: "capo_devops_agent.types.token_value.TokenValue"
+    """<p>Bearer token value in alphanumeric for authenticating with the service.</p>"""
+    authorization_header: "str"
+    """<p>HTTP header name to send the bearer token in requests to the service. Defaults to 'Authorization' per RFC 6750.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerBearerTokenConfig) -> dict:
+    out: dict = {}
+    out["tokenName"] = value["token_name"]
+    out["tokenValue"] = value["token_value"]
+    out["authorizationHeader"] = value.get("authorization_header", "Authorization")
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerBearerTokenConfig:
+    out: MCPServerBearerTokenConfig = {}  # type: ignore[typeddict-item]
+    if data.get("tokenName") is not None:
+        out["token_name"] = data["tokenName"]
+    else:
+        raise DeserializationError("MCPServerBearerTokenConfig.token_name required")
+    if data.get("tokenValue") is not None:
+        out["token_value"] = data["tokenValue"]
+    else:
+        raise DeserializationError("MCPServerBearerTokenConfig.token_value required")
+    if data.get("authorizationHeader") is not None:
+        out["authorization_header"] = data["authorizationHeader"]
+    else:
+        out["authorization_header"] = "Authorization"
+    return out

capo_devops_agent/types/mcp_server_configuration.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.mcp_tools_list
+
+
+class MCPServerConfiguration(TypedDict, closed=True):
+    tools: "capo_devops_agent.types.mcp_tools_list.MCPToolsList"
+    """<p>List of MCP tools can be used with the association.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerConfiguration) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.mcp_tools_list
+
+    out["tools"] = capo_devops_agent.types.mcp_tools_list.serialize_json(value["tools"])
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerConfiguration:
+    out: MCPServerConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("tools") is not None:
+        import capo_devops_agent.types.mcp_tools_list
+
+        out["tools"] = capo_devops_agent.types.mcp_tools_list.deserialize_json(
+            data["tools"]
+        )
+    else:
+        raise DeserializationError("MCPServerConfiguration.tools required")
+    return out

capo_devops_agent/types/mcp_server_datadog_configuration.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerDatadogConfiguration``."""
+
+from typing_extensions import TypedDict
+
+
+class MCPServerDatadogConfiguration(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerDatadogConfiguration) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerDatadogConfiguration:
+    out: MCPServerDatadogConfiguration = {}  # type: ignore[typeddict-item]
+    return out

capo_devops_agent/types/mcp_server_details.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.description
+    import capo_devops_agent.types.mcp_server_authorization_config
+    import capo_devops_agent.types.mcp_server_endpoint
+    import capo_devops_agent.types.mcp_server_name
+
+
+class MCPServerDetails(TypedDict, closed=True):
+    name: "capo_devops_agent.types.mcp_server_name.MCPServerName"
+    """<p>MCP server name.</p>"""
+    endpoint: "capo_devops_agent.types.mcp_server_endpoint.MCPServerEndpoint"
+    """<p>MCP server endpoint URL.</p>"""
+    description: NotRequired["capo_devops_agent.types.description.Description"]
+    """<p>Optional description for the MCP server.</p>"""
+    authorization_config: "capo_devops_agent.types.mcp_server_authorization_config.MCPServerAuthorizationConfig"
+    """<p>MCP server authorization configuration.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerDetails) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["endpoint"] = value["endpoint"]
+    if "description" in value:
+        out["description"] = value["description"]
+    import capo_devops_agent.types.mcp_server_authorization_config
+
+    out["authorizationConfig"] = (
+        capo_devops_agent.types.mcp_server_authorization_config.serialize_json(
+            value["authorization_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerDetails:
+    out: MCPServerDetails = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("MCPServerDetails.name required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("MCPServerDetails.endpoint required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("authorizationConfig") is not None:
+        import capo_devops_agent.types.mcp_server_authorization_config
+
+        out["authorization_config"] = (
+            capo_devops_agent.types.mcp_server_authorization_config.deserialize_json(
+                data["authorizationConfig"]
+            )
+        )
+    else:
+        raise DeserializationError("MCPServerDetails.authorization_config required")
+    return out

capo_devops_agent/types/mcp_server_endpoint.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerEndpoint``."""
+
+from typing import TypeAlias
+
+"""<p>HTTPS endpoint URL for an MCP server.</p>"""
+MCPServerEndpoint: TypeAlias = str

capo_devops_agent/types/mcp_server_grafana_configuration.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerGrafanaConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.mcp_tools_list
+
+
+class MCPServerGrafanaConfiguration(TypedDict, closed=True):
+    endpoint: "str"
+    """<p>Grafana instance URL (e.g., https://your-instance.grafana.net)</p>"""
+    organization_id: NotRequired["str"]
+    """<p>The Grafana organization ID that can be used.</p>"""
+    tools: NotRequired["capo_devops_agent.types.mcp_tools_list.MCPToolsList"]
+    """<p>List of MCP tools that can be used.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerGrafanaConfiguration) -> dict:
+    out: dict = {}
+    out["endpoint"] = value["endpoint"]
+    if "organization_id" in value:
+        out["organizationId"] = value["organization_id"]
+    if "tools" in value:
+        import capo_devops_agent.types.mcp_tools_list
+
+        out["tools"] = capo_devops_agent.types.mcp_tools_list.serialize_json(
+            value["tools"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerGrafanaConfiguration:
+    out: MCPServerGrafanaConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("MCPServerGrafanaConfiguration.endpoint required")
+    if data.get("organizationId") is not None:
+        out["organization_id"] = data["organizationId"]
+    if data.get("tools") is not None:
+        import capo_devops_agent.types.mcp_tools_list
+
+        out["tools"] = capo_devops_agent.types.mcp_tools_list.deserialize_json(
+            data["tools"]
+        )
+    return out

capo_devops_agent/types/mcp_server_name.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerName``."""
+
+from typing import TypeAlias
+
+"""<p>Name identifier for an MCP server.</p>"""
+MCPServerName: TypeAlias = str

capo_devops_agent/types/mcp_server_new_relic_configuration.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerNewRelicConfiguration``."""
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class MCPServerNewRelicConfiguration(TypedDict, closed=True):
+    account_id: "str"
+    """<p>New Relic Account ID</p>"""
+    endpoint: "str"
+    """<p>MCP server endpoint URL (e.g., https://mcp.newrelic.com/mcp/)</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerNewRelicConfiguration) -> dict:
+    out: dict = {}
+    out["accountId"] = value["account_id"]
+    out["endpoint"] = value["endpoint"]
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerNewRelicConfiguration:
+    out: MCPServerNewRelicConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("accountId") is not None:
+        out["account_id"] = data["accountId"]
+    else:
+        raise DeserializationError("MCPServerNewRelicConfiguration.account_id required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("MCPServerNewRelicConfiguration.endpoint required")
+    return out

capo_devops_agent/types/mcp_server_o_auth3_lo_config.py

@@ -0,0 +1,106 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerOAuth3LOConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.client_id
+    import capo_devops_agent.types.client_secret
+    import capo_devops_agent.types.exchange_parameters
+    import capo_devops_agent.types.scopes
+
+
+class MCPServerOAuth3LOConfig(TypedDict, closed=True):
+    client_name: NotRequired["str"]
+    """<p>User friendly OAuth client name specified by end user.</p>"""
+    client_id: "capo_devops_agent.types.client_id.ClientId"
+    """<p>OAuth client ID for authenticating with the service.</p>"""
+    exchange_parameters: NotRequired[
+        "capo_devops_agent.types.exchange_parameters.ExchangeParameters"
+    ]
+    """<p>OAuth token exchange parameters for authenticating with the service.</p>"""
+    return_to_endpoint: "str"
+    """<p>The endpoint to return to after OAuth flow completes (must be AWS console domain)</p>"""
+    authorization_url: "str"
+    """<p>OAuth authorization URL for 3LO authentication.</p>"""
+    exchange_url: "str"
+    """<p>OAuth token exchange URL.</p>"""
+    client_secret: NotRequired["capo_devops_agent.types.client_secret.ClientSecret"]
+    """<p>OAuth client secret for authenticating with the service. Required for confidential clients or when PKCE is not supported. Optional for public clients using PKCE.</p>"""
+    support_code_challenge: "bool"
+    """<p>Whether the service supports PKCE (Proof Key for Code Exchange) for enhanced security during the OAuth flow.</p>"""
+    scopes: NotRequired["capo_devops_agent.types.scopes.Scopes"]
+    """<p>OAuth scopes for 3LO authentication. The service will always request scope offline_access.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerOAuth3LOConfig) -> dict:
+    out: dict = {}
+    if "client_name" in value:
+        out["clientName"] = value["client_name"]
+    out["clientId"] = value["client_id"]
+    if "exchange_parameters" in value:
+        import capo_devops_agent.types.exchange_parameters
+
+        out["exchangeParameters"] = (
+            capo_devops_agent.types.exchange_parameters.serialize_json(
+                value["exchange_parameters"]
+            )
+        )
+    out["returnToEndpoint"] = value["return_to_endpoint"]
+    out["authorizationUrl"] = value["authorization_url"]
+    out["exchangeUrl"] = value["exchange_url"]
+    if "client_secret" in value:
+        out["clientSecret"] = value["client_secret"]
+    out["supportCodeChallenge"] = value.get("support_code_challenge", False)
+    if "scopes" in value:
+        import capo_devops_agent.types.scopes
+
+        out["scopes"] = capo_devops_agent.types.scopes.serialize_json(value["scopes"])
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerOAuth3LOConfig:
+    out: MCPServerOAuth3LOConfig = {}  # type: ignore[typeddict-item]
+    if data.get("clientName") is not None:
+        out["client_name"] = data["clientName"]
+    if data.get("clientId") is not None:
+        out["client_id"] = data["clientId"]
+    else:
+        raise DeserializationError("MCPServerOAuth3LOConfig.client_id required")
+    if data.get("exchangeParameters") is not None:
+        import capo_devops_agent.types.exchange_parameters
+
+        out["exchange_parameters"] = (
+            capo_devops_agent.types.exchange_parameters.deserialize_json(
+                data["exchangeParameters"]
+            )
+        )
+    if data.get("returnToEndpoint") is not None:
+        out["return_to_endpoint"] = data["returnToEndpoint"]
+    else:
+        raise DeserializationError(
+            "MCPServerOAuth3LOConfig.return_to_endpoint required"
+        )
+    if data.get("authorizationUrl") is not None:
+        out["authorization_url"] = data["authorizationUrl"]
+    else:
+        raise DeserializationError("MCPServerOAuth3LOConfig.authorization_url required")
+    if data.get("exchangeUrl") is not None:
+        out["exchange_url"] = data["exchangeUrl"]
+    else:
+        raise DeserializationError("MCPServerOAuth3LOConfig.exchange_url required")
+    if data.get("clientSecret") is not None:
+        out["client_secret"] = data["clientSecret"]
+    if data.get("supportCodeChallenge") is not None:
+        out["support_code_challenge"] = data["supportCodeChallenge"]
+    else:
+        out["support_code_challenge"] = False
+    if data.get("scopes") is not None:
+        import capo_devops_agent.types.scopes
+
+        out["scopes"] = capo_devops_agent.types.scopes.deserialize_json(data["scopes"])
+    return out

capo_devops_agent/types/mcp_server_o_auth_client_credentials_config.py

@@ -0,0 +1,90 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerOAuthClientCredentialsConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.client_id
+    import capo_devops_agent.types.client_secret
+    import capo_devops_agent.types.exchange_parameters
+    import capo_devops_agent.types.scopes
+
+
+class MCPServerOAuthClientCredentialsConfig(TypedDict, closed=True):
+    client_name: NotRequired["str"]
+    """<p>User friendly OAuth client name specified by end user.</p>"""
+    client_id: "capo_devops_agent.types.client_id.ClientId"
+    """<p>OAuth client ID for authenticating with the service.</p>"""
+    exchange_parameters: NotRequired[
+        "capo_devops_agent.types.exchange_parameters.ExchangeParameters"
+    ]
+    """<p>OAuth token exchange parameters for authenticating with the service.</p>"""
+    client_secret: "capo_devops_agent.types.client_secret.ClientSecret"
+    """<p>OAuth client secret for authenticating with the service.</p>"""
+    exchange_url: "str"
+    """<p>OAuth token exchange URL.</p>"""
+    scopes: NotRequired["capo_devops_agent.types.scopes.Scopes"]
+    """<p>OAuth scopes for 3LO authentication. The service will always request scope offline_access.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerOAuthClientCredentialsConfig) -> dict:
+    out: dict = {}
+    if "client_name" in value:
+        out["clientName"] = value["client_name"]
+    out["clientId"] = value["client_id"]
+    if "exchange_parameters" in value:
+        import capo_devops_agent.types.exchange_parameters
+
+        out["exchangeParameters"] = (
+            capo_devops_agent.types.exchange_parameters.serialize_json(
+                value["exchange_parameters"]
+            )
+        )
+    out["clientSecret"] = value["client_secret"]
+    out["exchangeUrl"] = value["exchange_url"]
+    if "scopes" in value:
+        import capo_devops_agent.types.scopes
+
+        out["scopes"] = capo_devops_agent.types.scopes.serialize_json(value["scopes"])
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerOAuthClientCredentialsConfig:
+    out: MCPServerOAuthClientCredentialsConfig = {}  # type: ignore[typeddict-item]
+    if data.get("clientName") is not None:
+        out["client_name"] = data["clientName"]
+    if data.get("clientId") is not None:
+        out["client_id"] = data["clientId"]
+    else:
+        raise DeserializationError(
+            "MCPServerOAuthClientCredentialsConfig.client_id required"
+        )
+    if data.get("exchangeParameters") is not None:
+        import capo_devops_agent.types.exchange_parameters
+
+        out["exchange_parameters"] = (
+            capo_devops_agent.types.exchange_parameters.deserialize_json(
+                data["exchangeParameters"]
+            )
+        )
+    if data.get("clientSecret") is not None:
+        out["client_secret"] = data["clientSecret"]
+    else:
+        raise DeserializationError(
+            "MCPServerOAuthClientCredentialsConfig.client_secret required"
+        )
+    if data.get("exchangeUrl") is not None:
+        out["exchange_url"] = data["exchangeUrl"]
+    else:
+        raise DeserializationError(
+            "MCPServerOAuthClientCredentialsConfig.exchange_url required"
+        )
+    if data.get("scopes") is not None:
+        import capo_devops_agent.types.scopes
+
+        out["scopes"] = capo_devops_agent.types.scopes.deserialize_json(data["scopes"])
+    return out