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

capo_devops_agent/types/register_service_input.py

@@ -0,0 +1,101 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisterServiceInput``."""
+
+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.kms_key_arn
+    import capo_devops_agent.types.post_register_service_supported_service
+    import capo_devops_agent.types.private_connection_name
+    import capo_devops_agent.types.service_details
+    import capo_devops_agent.types.service_name
+    import capo_devops_agent.types.tags
+
+
+class RegisterServiceInput(TypedDict, closed=True):
+    service: "capo_devops_agent.types.post_register_service_supported_service.PostRegisterServiceSupportedService"
+    service_details: "capo_devops_agent.types.service_details.ServiceDetails"
+    """<p>Service-specific authorization configuration parameters</p>"""
+    kms_key_arn: NotRequired["capo_devops_agent.types.kms_key_arn.KmsKeyArn"]
+    """<p>The ARN of the AWS Key Management Service (AWS KMS) customer managed key that's used to encrypt resources.</p>"""
+    private_connection_name: NotRequired[
+        "capo_devops_agent.types.private_connection_name.PrivateConnectionName"
+    ]
+    """<p>The name of the private connection to use for VPC connectivity.</p>"""
+    target_url_private_connection_name: NotRequired[
+        "capo_devops_agent.types.private_connection_name.PrivateConnectionName"
+    ]
+    """<p>The name of the private connection to use for API calls (target URL) only. Cannot be specified when privateConnectionName is provided.</p>"""
+    exchange_url_private_connection_name: NotRequired[
+        "capo_devops_agent.types.private_connection_name.PrivateConnectionName"
+    ]
+    """<p>The name of the private connection to use for OAuth token exchange requests only. Cannot be specified when privateConnectionName is provided.</p>"""
+    name: NotRequired["capo_devops_agent.types.service_name.ServiceName"]
+    """<p>The display name for the service registration.</p>"""
+    tags: NotRequired["capo_devops_agent.types.tags.Tags"]
+    """<p>Tags to add to the Service at registration time.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisterServiceInput) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.service_details
+
+    out["serviceDetails"] = capo_devops_agent.types.service_details.serialize_json(
+        value["service_details"]
+    )
+    if "kms_key_arn" in value:
+        out["kmsKeyArn"] = value["kms_key_arn"]
+    if "private_connection_name" in value:
+        out["privateConnectionName"] = value["private_connection_name"]
+    if "target_url_private_connection_name" in value:
+        out["targetUrlPrivateConnectionName"] = value[
+            "target_url_private_connection_name"
+        ]
+    if "exchange_url_private_connection_name" in value:
+        out["exchangeUrlPrivateConnectionName"] = value[
+            "exchange_url_private_connection_name"
+        ]
+    if "name" in value:
+        out["name"] = value["name"]
+    if "tags" in value:
+        import capo_devops_agent.types.tags
+
+        out["tags"] = capo_devops_agent.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> RegisterServiceInput:
+    out: RegisterServiceInput = {}  # type: ignore[typeddict-item]
+    if data.get("serviceDetails") is not None:
+        import capo_devops_agent.types.service_details
+
+        out["service_details"] = (
+            capo_devops_agent.types.service_details.deserialize_json(
+                data["serviceDetails"]
+            )
+        )
+    else:
+        raise DeserializationError("RegisterServiceInput.service_details required")
+    if data.get("kmsKeyArn") is not None:
+        out["kms_key_arn"] = data["kmsKeyArn"]
+    if data.get("privateConnectionName") is not None:
+        out["private_connection_name"] = data["privateConnectionName"]
+    if data.get("targetUrlPrivateConnectionName") is not None:
+        out["target_url_private_connection_name"] = data[
+            "targetUrlPrivateConnectionName"
+        ]
+    if data.get("exchangeUrlPrivateConnectionName") is not None:
+        out["exchange_url_private_connection_name"] = data[
+            "exchangeUrlPrivateConnectionName"
+        ]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    if data.get("tags") is not None:
+        import capo_devops_agent.types.tags
+
+        out["tags"] = capo_devops_agent.types.tags.deserialize_json(data["tags"])
+    return out

capo_devops_agent/types/register_service_output.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisterServiceOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.additional_service_registration_step
+    import capo_devops_agent.types.kms_key_arn
+    import capo_devops_agent.types.service_id
+    import capo_devops_agent.types.tags
+
+
+class RegisterServiceOutput(TypedDict, closed=True):
+    service_id: NotRequired["capo_devops_agent.types.service_id.ServiceId"]
+    """<p>Service ID - present when registration is complete, absent when additional steps are required</p>"""
+    additional_step: NotRequired[
+        "capo_devops_agent.types.additional_service_registration_step.AdditionalServiceRegistrationStep"
+    ]
+    """<p>Indicates if additional steps are required to complete service registration (e.g., 3-legged OAuth)</p>"""
+    kms_key_arn: NotRequired["capo_devops_agent.types.kms_key_arn.KmsKeyArn"]
+    """<p>The ARN of the AWS Key Management Service (AWS KMS) customer managed key that's used to encrypt resources.</p>"""
+    tags: NotRequired["capo_devops_agent.types.tags.Tags"]
+    """<p>Tags associated with the registered Service.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisterServiceOutput) -> dict:
+    out: dict = {}
+    if "service_id" in value:
+        out["serviceId"] = value["service_id"]
+    if "additional_step" in value:
+        import capo_devops_agent.types.additional_service_registration_step
+
+        out["additionalStep"] = (
+            capo_devops_agent.types.additional_service_registration_step.serialize_json(
+                value["additional_step"]
+            )
+        )
+    if "kms_key_arn" in value:
+        out["kmsKeyArn"] = value["kms_key_arn"]
+    if "tags" in value:
+        import capo_devops_agent.types.tags
+
+        out["tags"] = capo_devops_agent.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> RegisterServiceOutput:
+    out: RegisterServiceOutput = {}  # type: ignore[typeddict-item]
+    if data.get("serviceId") is not None:
+        out["service_id"] = data["serviceId"]
+    if data.get("additionalStep") is not None:
+        import capo_devops_agent.types.additional_service_registration_step
+
+        out["additional_step"] = (
+            capo_devops_agent.types.additional_service_registration_step.deserialize_json(
+                data["additionalStep"]
+            )
+        )
+    if data.get("kmsKeyArn") is not None:
+        out["kms_key_arn"] = data["kmsKeyArn"]
+    if data.get("tags") is not None:
+        import capo_devops_agent.types.tags
+
+        out["tags"] = capo_devops_agent.types.tags.deserialize_json(data["tags"])
+    return out

capo_devops_agent/types/registered_azure_dev_ops_service_details.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredAzureDevOpsServiceDetails``."""
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class RegisteredAzureDevOpsServiceDetails(TypedDict, closed=True):
+    organization_name: "str"
+    """<p>The Azure DevOps Organization name associated with the service.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredAzureDevOpsServiceDetails) -> dict:
+    out: dict = {}
+    out["organizationName"] = value["organization_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredAzureDevOpsServiceDetails:
+    out: RegisteredAzureDevOpsServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("organizationName") is not None:
+        out["organization_name"] = data["organizationName"]
+    else:
+        raise DeserializationError(
+            "RegisteredAzureDevOpsServiceDetails.organization_name required"
+        )
+    return out

capo_devops_agent/types/registered_azure_identity_details.py

@@ -0,0 +1,70 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredAzureIdentityDetails``."""
+
+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.guid
+    import capo_devops_agent.types.role_arn
+    import capo_devops_agent.types.web_identity_token_audience_list
+
+
+class RegisteredAzureIdentityDetails(TypedDict, closed=True):
+    tenant_id: "capo_devops_agent.types.guid.Guid"
+    """<p>The Azure Active Directory tenant ID for the identity.</p>"""
+    client_id: "capo_devops_agent.types.guid.Guid"
+    """<p>The client ID of the service principal or managed identity used for authentication.</p>"""
+    web_identity_role_arn: "capo_devops_agent.types.role_arn.RoleArn"
+    """<p>The role ARN to be assumed by DevOps Agent for requesting Web Identity Token.</p>"""
+    web_identity_token_audiences: "capo_devops_agent.types.web_identity_token_audience_list.WebIdentityTokenAudienceList"
+    """<p>The audiences for the Web Identity Token.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredAzureIdentityDetails) -> dict:
+    out: dict = {}
+    out["tenantId"] = value["tenant_id"]
+    out["clientId"] = value["client_id"]
+    out["webIdentityRoleArn"] = value["web_identity_role_arn"]
+    import capo_devops_agent.types.web_identity_token_audience_list
+
+    out["webIdentityTokenAudiences"] = (
+        capo_devops_agent.types.web_identity_token_audience_list.serialize_json(
+            value["web_identity_token_audiences"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredAzureIdentityDetails:
+    out: RegisteredAzureIdentityDetails = {}  # type: ignore[typeddict-item]
+    if data.get("tenantId") is not None:
+        out["tenant_id"] = data["tenantId"]
+    else:
+        raise DeserializationError("RegisteredAzureIdentityDetails.tenant_id required")
+    if data.get("clientId") is not None:
+        out["client_id"] = data["clientId"]
+    else:
+        raise DeserializationError("RegisteredAzureIdentityDetails.client_id required")
+    if data.get("webIdentityRoleArn") is not None:
+        out["web_identity_role_arn"] = data["webIdentityRoleArn"]
+    else:
+        raise DeserializationError(
+            "RegisteredAzureIdentityDetails.web_identity_role_arn required"
+        )
+    if data.get("webIdentityTokenAudiences") is not None:
+        import capo_devops_agent.types.web_identity_token_audience_list
+
+        out["web_identity_token_audiences"] = (
+            capo_devops_agent.types.web_identity_token_audience_list.deserialize_json(
+                data["webIdentityTokenAudiences"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "RegisteredAzureIdentityDetails.web_identity_token_audiences required"
+        )
+    return out

capo_devops_agent/types/registered_git_lab_service_details.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredGitLabServiceDetails``."""
+
+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.git_lab_token_type
+
+
+class RegisteredGitLabServiceDetails(TypedDict, closed=True):
+    target_url: "str"
+    """<p>The GitLab instance URL.</p>"""
+    token_type: "capo_devops_agent.types.git_lab_token_type.GitLabTokenType"
+    """<p>Type of GitLab access token</p>"""
+    group_id: NotRequired["str"]
+    """<p>Optional GitLab group ID for group-level access tokens</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredGitLabServiceDetails) -> dict:
+    out: dict = {}
+    out["targetUrl"] = value["target_url"]
+    import capo_devops_agent.types.git_lab_token_type
+
+    out["tokenType"] = capo_devops_agent.types.git_lab_token_type.serialize_json(
+        value["token_type"]
+    )
+    if "group_id" in value:
+        out["groupId"] = value["group_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredGitLabServiceDetails:
+    out: RegisteredGitLabServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("targetUrl") is not None:
+        out["target_url"] = data["targetUrl"]
+    else:
+        raise DeserializationError("RegisteredGitLabServiceDetails.target_url required")
+    if data.get("tokenType") is not None:
+        import capo_devops_agent.types.git_lab_token_type
+
+        out["token_type"] = capo_devops_agent.types.git_lab_token_type.deserialize_json(
+            data["tokenType"]
+        )
+    else:
+        raise DeserializationError("RegisteredGitLabServiceDetails.token_type required")
+    if data.get("groupId") is not None:
+        out["group_id"] = data["groupId"]
+    return out

capo_devops_agent/types/registered_github_service_details.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredGithubServiceDetails``."""
+
+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.github_repo_owner_type
+
+
+class RegisteredGithubServiceDetails(TypedDict, closed=True):
+    owner: "str"
+    """<p>The GitHub repository owner name.</p>"""
+    owner_type: "capo_devops_agent.types.github_repo_owner_type.GithubRepoOwnerType"
+    """<p>The GitHub repository owner type.</p>"""
+    target_url: NotRequired["str"]
+    """<p>The GitHub Enterprise Server instance URL (absent for github.com).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredGithubServiceDetails) -> dict:
+    out: dict = {}
+    out["owner"] = value["owner"]
+    import capo_devops_agent.types.github_repo_owner_type
+
+    out["ownerType"] = capo_devops_agent.types.github_repo_owner_type.serialize_json(
+        value["owner_type"]
+    )
+    if "target_url" in value:
+        out["targetUrl"] = value["target_url"]
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredGithubServiceDetails:
+    out: RegisteredGithubServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("owner") is not None:
+        out["owner"] = data["owner"]
+    else:
+        raise DeserializationError("RegisteredGithubServiceDetails.owner required")
+    if data.get("ownerType") is not None:
+        import capo_devops_agent.types.github_repo_owner_type
+
+        out["owner_type"] = (
+            capo_devops_agent.types.github_repo_owner_type.deserialize_json(
+                data["ownerType"]
+            )
+        )
+    else:
+        raise DeserializationError("RegisteredGithubServiceDetails.owner_type required")
+    if data.get("targetUrl") is not None:
+        out["target_url"] = data["targetUrl"]
+    return out

capo_devops_agent/types/registered_grafana_server_details.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredGrafanaServerDetails``."""
+
+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_server_authorization_method
+    import capo_devops_agent.types.mcp_server_endpoint
+
+
+class RegisteredGrafanaServerDetails(TypedDict, closed=True):
+    endpoint: "capo_devops_agent.types.mcp_server_endpoint.MCPServerEndpoint"
+    """<p>Grafana instance URL (e.g., https://your-instance.grafana.net)</p>"""
+    authorization_method: "capo_devops_agent.types.mcp_server_authorization_method.MCPServerAuthorizationMethod"
+    """<p>The authz method used by the MCP server.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredGrafanaServerDetails) -> dict:
+    out: dict = {}
+    out["endpoint"] = value["endpoint"]
+    import capo_devops_agent.types.mcp_server_authorization_method
+
+    out["authorizationMethod"] = (
+        capo_devops_agent.types.mcp_server_authorization_method.serialize_json(
+            value["authorization_method"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredGrafanaServerDetails:
+    out: RegisteredGrafanaServerDetails = {}  # type: ignore[typeddict-item]
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("RegisteredGrafanaServerDetails.endpoint required")
+    if data.get("authorizationMethod") is not None:
+        import capo_devops_agent.types.mcp_server_authorization_method
+
+        out["authorization_method"] = (
+            capo_devops_agent.types.mcp_server_authorization_method.deserialize_json(
+                data["authorizationMethod"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "RegisteredGrafanaServerDetails.authorization_method required"
+        )
+    return out

capo_devops_agent/types/registered_mcp_server_details.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredMCPServerDetails``."""
+
+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_method
+
+
+class RegisteredMCPServerDetails(TypedDict, closed=True):
+    name: "str"
+    """<p>The MCP server name.</p>"""
+    endpoint: "str"
+    """<p>The MCP server endpoint URL.</p>"""
+    authorization_method: "capo_devops_agent.types.mcp_server_authorization_method.MCPServerAuthorizationMethod"
+    """<p>The MCP server uses this authorization method.</p>"""
+    description: NotRequired["capo_devops_agent.types.description.Description"]
+    """<p>Optional description for the MCP server.</p>"""
+    api_key_header: NotRequired["str"]
+    """<p>If the MCP server uses API key authentication, these details are provided.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredMCPServerDetails) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["endpoint"] = value["endpoint"]
+    import capo_devops_agent.types.mcp_server_authorization_method
+
+    out["authorizationMethod"] = (
+        capo_devops_agent.types.mcp_server_authorization_method.serialize_json(
+            value["authorization_method"]
+        )
+    )
+    if "description" in value:
+        out["description"] = value["description"]
+    if "api_key_header" in value:
+        out["apiKeyHeader"] = value["api_key_header"]
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredMCPServerDetails:
+    out: RegisteredMCPServerDetails = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("RegisteredMCPServerDetails.name required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("RegisteredMCPServerDetails.endpoint required")
+    if data.get("authorizationMethod") is not None:
+        import capo_devops_agent.types.mcp_server_authorization_method
+
+        out["authorization_method"] = (
+            capo_devops_agent.types.mcp_server_authorization_method.deserialize_json(
+                data["authorizationMethod"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "RegisteredMCPServerDetails.authorization_method required"
+        )
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("apiKeyHeader") is not None:
+        out["api_key_header"] = data["apiKeyHeader"]
+    return out

capo_devops_agent/types/registered_mcp_server_sig_v4_details.py

@@ -0,0 +1,89 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredMCPServerSigV4Details``."""
+
+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.custom_headers
+    import capo_devops_agent.types.description
+    import capo_devops_agent.types.mcp_server_endpoint
+    import capo_devops_agent.types.mcp_server_name
+    import capo_devops_agent.types.role_arn
+    import capo_devops_agent.types.sig_v4_region
+
+
+class RegisteredMCPServerSigV4Details(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>"""
+    region: "capo_devops_agent.types.sig_v4_region.SigV4Region"
+    """<p>AWS region for SigV4 signing. Use '*' for SigV4a multi-region signing.</p>"""
+    service: "str"
+    """<p>AWS service name for SigV4 signing.</p>"""
+    role_arn: "str"
+    """<p>IAM role ARN to assume for SigV4 signing.</p>"""
+    mcp_role_arn: NotRequired["capo_devops_agent.types.role_arn.RoleArn"]
+    custom_headers: NotRequired["capo_devops_agent.types.custom_headers.CustomHeaders"]
+    """<p>Custom headers for the SigV4 MCP server.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredMCPServerSigV4Details) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    out["endpoint"] = value["endpoint"]
+    if "description" in value:
+        out["description"] = value["description"]
+    out["region"] = value["region"]
+    out["service"] = value["service"]
+    out["roleArn"] = value.get("role_arn", "")
+    if "mcp_role_arn" in value:
+        out["mcpRoleArn"] = value["mcp_role_arn"]
+    if "custom_headers" in value:
+        import capo_devops_agent.types.custom_headers
+
+        out["customHeaders"] = capo_devops_agent.types.custom_headers.serialize_json(
+            value["custom_headers"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredMCPServerSigV4Details:
+    out: RegisteredMCPServerSigV4Details = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("RegisteredMCPServerSigV4Details.name required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("RegisteredMCPServerSigV4Details.endpoint required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("region") is not None:
+        out["region"] = data["region"]
+    else:
+        raise DeserializationError("RegisteredMCPServerSigV4Details.region required")
+    if data.get("service") is not None:
+        out["service"] = data["service"]
+    else:
+        raise DeserializationError("RegisteredMCPServerSigV4Details.service required")
+    if data.get("roleArn") is not None:
+        out["role_arn"] = data["roleArn"]
+    else:
+        out["role_arn"] = ""
+    if data.get("mcpRoleArn") is not None:
+        out["mcp_role_arn"] = data["mcpRoleArn"]
+    if data.get("customHeaders") is not None:
+        import capo_devops_agent.types.custom_headers
+
+        out["custom_headers"] = capo_devops_agent.types.custom_headers.deserialize_json(
+            data["customHeaders"]
+        )
+    return out

capo_devops_agent/types/registered_new_relic_details.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#RegisteredNewRelicDetails``."""
+
+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.new_relic_region
+
+
+class RegisteredNewRelicDetails(TypedDict, closed=True):
+    account_id: "str"
+    """<p>The NewRelic account ID.</p>"""
+    region: "capo_devops_agent.types.new_relic_region.NewRelicRegion"
+    """<p>The NewRelic region (determines API endpoint).</p>"""
+    description: NotRequired["capo_devops_agent.types.description.Description"]
+    """<p>Optional user description.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegisteredNewRelicDetails) -> dict:
+    out: dict = {}
+    out["accountId"] = value["account_id"]
+    import capo_devops_agent.types.new_relic_region
+
+    out["region"] = capo_devops_agent.types.new_relic_region.serialize_json(
+        value["region"]
+    )
+    if "description" in value:
+        out["description"] = value["description"]
+    return out
+
+
+def deserialize_json(data: dict) -> RegisteredNewRelicDetails:
+    out: RegisteredNewRelicDetails = {}  # type: ignore[typeddict-item]
+    if data.get("accountId") is not None:
+        out["account_id"] = data["accountId"]
+    else:
+        raise DeserializationError("RegisteredNewRelicDetails.account_id required")
+    if data.get("region") is not None:
+        import capo_devops_agent.types.new_relic_region
+
+        out["region"] = capo_devops_agent.types.new_relic_region.deserialize_json(
+            data["region"]
+        )
+    else:
+        raise DeserializationError("RegisteredNewRelicDetails.region required")
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    return out