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

capo_devops_agent/types/list_journal_records_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListJournalRecordsResponse``."""
+
+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.journal_record_list
+
+
+class ListJournalRecordsResponse(TypedDict, closed=True):
+    records: "capo_devops_agent.types.journal_record_list.JournalRecordList"
+    """<p>List of journal records matching the request criteria</p>"""
+    next_token: NotRequired["str"]
+    """<p>Token for retrieving the next page of results, if more results are available</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListJournalRecordsResponse) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.journal_record_list
+
+    out["records"] = capo_devops_agent.types.journal_record_list.serialize_json(
+        value["records"]
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListJournalRecordsResponse:
+    out: ListJournalRecordsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("records") is not None:
+        import capo_devops_agent.types.journal_record_list
+
+        out["records"] = capo_devops_agent.types.journal_record_list.deserialize_json(
+            data["records"]
+        )
+    else:
+        raise DeserializationError("ListJournalRecordsResponse.records required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_devops_agent/types/list_of_security_group_ids.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListOfSecurityGroupIds``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.security_group_id
+
+ListOfSecurityGroupIds: TypeAlias = list[
+    "capo_devops_agent.types.security_group_id.SecurityGroupId"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListOfSecurityGroupIds) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> ListOfSecurityGroupIds:
+    return [item for item in data if item is not None]

capo_devops_agent/types/list_of_subnet_ids.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListOfSubnetIds``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.subnet_id
+
+ListOfSubnetIds: TypeAlias = list["capo_devops_agent.types.subnet_id.SubnetId"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListOfSubnetIds) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> ListOfSubnetIds:
+    return [item for item in data if item is not None]

capo_devops_agent/types/list_pending_messages_request.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListPendingMessagesRequest``."""
+
+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.agent_space_id
+    import capo_devops_agent.types.resource_id
+
+
+class ListPendingMessagesRequest(TypedDict, closed=True):
+    agent_space_id: "capo_devops_agent.types.agent_space_id.AgentSpaceId"
+    execution_id: "capo_devops_agent.types.resource_id.ResourceId"
+    """<p>The unique identifier of the execution whose journal records to retrieve</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListPendingMessagesRequest) -> dict:
+    out: dict = {}
+    out["executionId"] = value["execution_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListPendingMessagesRequest:
+    out: ListPendingMessagesRequest = {}  # type: ignore[typeddict-item]
+    if data.get("executionId") is not None:
+        out["execution_id"] = data["executionId"]
+    else:
+        raise DeserializationError("ListPendingMessagesRequest.execution_id required")
+    return out

capo_devops_agent/types/list_pending_messages_response.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListPendingMessagesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import datetime
+
+    import capo_devops_agent.types.agent_space_id
+    import capo_devops_agent.types.pending_messages
+
+
+class ListPendingMessagesResponse(TypedDict, closed=True):
+    agent_space_id: "capo_devops_agent.types.agent_space_id.AgentSpaceId"
+    execution_id: "str"
+    """<p>The unique identifier for the execution.</p>"""
+    messages: "capo_devops_agent.types.pending_messages.PendingMessages"
+    """<p>The list of pending messages for the execution.</p>"""
+    created_at: "datetime.datetime"
+    """<p>Timestamp when the pending messages were created.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListPendingMessagesResponse) -> dict:
+    out: dict = {}
+    out["agentSpaceId"] = value["agent_space_id"]
+    out["executionId"] = value["execution_id"]
+    import capo_devops_agent.types.pending_messages
+
+    out["messages"] = capo_devops_agent.types.pending_messages.serialize_json(
+        value.get("messages", [])
+    )
+    import capo_devops_agent.types._prelude.timestamp
+
+    out["createdAt"] = capo_devops_agent.types._prelude.timestamp.serialize_json(
+        value["created_at"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListPendingMessagesResponse:
+    out: ListPendingMessagesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("agentSpaceId") is not None:
+        out["agent_space_id"] = data["agentSpaceId"]
+    else:
+        raise DeserializationError(
+            "ListPendingMessagesResponse.agent_space_id required"
+        )
+    if data.get("executionId") is not None:
+        out["execution_id"] = data["executionId"]
+    else:
+        raise DeserializationError("ListPendingMessagesResponse.execution_id required")
+    if data.get("messages") is not None:
+        import capo_devops_agent.types.pending_messages
+
+        out["messages"] = capo_devops_agent.types.pending_messages.deserialize_json(
+            data["messages"]
+        )
+    else:
+        out["messages"] = []
+    if data.get("createdAt") is not None:
+        import capo_devops_agent.types._prelude.timestamp
+
+        out["created_at"] = capo_devops_agent.types._prelude.timestamp.deserialize_json(
+            data["createdAt"]
+        )
+    else:
+        raise DeserializationError("ListPendingMessagesResponse.created_at required")
+    return out

capo_devops_agent/types/list_private_connections_input.py

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

capo_devops_agent/types/list_private_connections_output.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListPrivateConnectionsOutput``."""
+
+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.private_connection_summary_list
+
+
+class ListPrivateConnectionsOutput(TypedDict, closed=True):
+    private_connections: "capo_devops_agent.types.private_connection_summary_list.PrivateConnectionSummaryList"
+    """<p>The list of Private Connections.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListPrivateConnectionsOutput) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.private_connection_summary_list
+
+    out["privateConnections"] = (
+        capo_devops_agent.types.private_connection_summary_list.serialize_json(
+            value["private_connections"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListPrivateConnectionsOutput:
+    out: ListPrivateConnectionsOutput = {}  # type: ignore[typeddict-item]
+    if data.get("privateConnections") is not None:
+        import capo_devops_agent.types.private_connection_summary_list
+
+        out["private_connections"] = (
+            capo_devops_agent.types.private_connection_summary_list.deserialize_json(
+                data["privateConnections"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListPrivateConnectionsOutput.private_connections required"
+        )
+    return out

capo_devops_agent/types/list_recommendations_request.py

@@ -0,0 +1,89 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListRecommendationsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.agent_space_id
+    import capo_devops_agent.types.next_token
+    import capo_devops_agent.types.recommendation_priority
+    import capo_devops_agent.types.recommendation_status
+    import capo_devops_agent.types.resource_id
+
+
+class ListRecommendationsRequest(TypedDict, closed=True):
+    agent_space_id: "capo_devops_agent.types.agent_space_id.AgentSpaceId"
+    """<p>The unique identifier for the agent space containing the recommendations</p>"""
+    task_id: NotRequired["capo_devops_agent.types.resource_id.ResourceId"]
+    """<p>Optional task ID to filter recommendations by specific task</p>"""
+    goal_id: NotRequired["capo_devops_agent.types.resource_id.ResourceId"]
+    """<p>Optional goal ID to filter recommendations by specific goal</p>"""
+    status: NotRequired[
+        "capo_devops_agent.types.recommendation_status.RecommendationStatus"
+    ]
+    """<p>Optional status to filter recommendations by their current status</p>"""
+    priority: NotRequired[
+        "capo_devops_agent.types.recommendation_priority.RecommendationPriority"
+    ]
+    """<p>Optional priority to filter recommendations by priority level</p>"""
+    limit: "int"
+    """<p>Maximum number of recommendations to return in a single response</p>"""
+    next_token: NotRequired["capo_devops_agent.types.next_token.NextToken"]
+    """<p>Token for retrieving the next page of results</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListRecommendationsRequest) -> dict:
+    out: dict = {}
+    if "task_id" in value:
+        out["taskId"] = value["task_id"]
+    if "goal_id" in value:
+        out["goalId"] = value["goal_id"]
+    if "status" in value:
+        import capo_devops_agent.types.recommendation_status
+
+        out["status"] = capo_devops_agent.types.recommendation_status.serialize_json(
+            value["status"]
+        )
+    if "priority" in value:
+        import capo_devops_agent.types.recommendation_priority
+
+        out["priority"] = (
+            capo_devops_agent.types.recommendation_priority.serialize_json(
+                value["priority"]
+            )
+        )
+    out["limit"] = value.get("limit", 50)
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListRecommendationsRequest:
+    out: ListRecommendationsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("taskId") is not None:
+        out["task_id"] = data["taskId"]
+    if data.get("goalId") is not None:
+        out["goal_id"] = data["goalId"]
+    if data.get("status") is not None:
+        import capo_devops_agent.types.recommendation_status
+
+        out["status"] = capo_devops_agent.types.recommendation_status.deserialize_json(
+            data["status"]
+        )
+    if data.get("priority") is not None:
+        import capo_devops_agent.types.recommendation_priority
+
+        out["priority"] = (
+            capo_devops_agent.types.recommendation_priority.deserialize_json(
+                data["priority"]
+            )
+        )
+    if data.get("limit") is not None:
+        out["limit"] = data["limit"]
+    else:
+        out["limit"] = 50
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_devops_agent/types/list_recommendations_response.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListRecommendationsResponse``."""
+
+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.recommendation_list
+
+
+class ListRecommendationsResponse(TypedDict, closed=True):
+    recommendations: "capo_devops_agent.types.recommendation_list.RecommendationList"
+    """<p>List of recommendations matching the request criteria</p>"""
+    next_token: NotRequired["str"]
+    """<p>Token for retrieving the next page of results, if more results are available</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListRecommendationsResponse) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.recommendation_list
+
+    out["recommendations"] = capo_devops_agent.types.recommendation_list.serialize_json(
+        value["recommendations"]
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListRecommendationsResponse:
+    out: ListRecommendationsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("recommendations") is not None:
+        import capo_devops_agent.types.recommendation_list
+
+        out["recommendations"] = (
+            capo_devops_agent.types.recommendation_list.deserialize_json(
+                data["recommendations"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListRecommendationsResponse.recommendations required"
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_devops_agent/types/list_services_input.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListServicesInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.next_token
+    import capo_devops_agent.types.service
+
+
+class ListServicesInput(TypedDict, closed=True):
+    max_results: "int"
+    """<p>Maximum number of results to return in a single call.</p>"""
+    next_token: NotRequired["capo_devops_agent.types.next_token.NextToken"]
+    """<p>Token for the next page of results.</p>"""
+    filter_service_type: NotRequired["capo_devops_agent.types.service.Service"]
+    """<p>Optional filter to list only services of a specific type.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListServicesInput) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListServicesInput:
+    out: ListServicesInput = {}  # type: ignore[typeddict-item]
+    return out

capo_devops_agent/types/list_services_output.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListServicesOutput``."""
+
+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.next_token
+    import capo_devops_agent.types.registered_services_list
+
+
+class ListServicesOutput(TypedDict, closed=True):
+    next_token: NotRequired["capo_devops_agent.types.next_token.NextToken"]
+    """<p>Token to retrieve the next page of results, if there are more results.</p>"""
+    services: "capo_devops_agent.types.registered_services_list.RegisteredServicesList"
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListServicesOutput) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    import capo_devops_agent.types.registered_services_list
+
+    out["services"] = capo_devops_agent.types.registered_services_list.serialize_json(
+        value["services"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListServicesOutput:
+    out: ListServicesOutput = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("services") is not None:
+        import capo_devops_agent.types.registered_services_list
+
+        out["services"] = (
+            capo_devops_agent.types.registered_services_list.deserialize_json(
+                data["services"]
+            )
+        )
+    else:
+        raise DeserializationError("ListServicesOutput.services required")
+    return out

capo_devops_agent/types/list_tags_for_resource_request.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListTagsForResourceRequest``."""
+
+from typing_extensions import TypedDict
+
+
+class ListTagsForResourceRequest(TypedDict, closed=True):
+    resource_arn: "str"
+    """<p>The ARN of the resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsForResourceRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListTagsForResourceRequest:
+    out: ListTagsForResourceRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_devops_agent/types/list_tags_for_resource_response.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListTagsForResourceResponse``."""
+
+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.tags
+
+
+class ListTagsForResourceResponse(TypedDict, closed=True):
+    tags: "capo_devops_agent.types.tags.Tags"
+    """<p>Tags associated with the resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsForResourceResponse) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.tags
+
+    out["tags"] = capo_devops_agent.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> ListTagsForResourceResponse:
+    out: ListTagsForResourceResponse = {}  # type: ignore[typeddict-item]
+    if data.get("tags") is not None:
+        import capo_devops_agent.types.tags
+
+        out["tags"] = capo_devops_agent.types.tags.deserialize_json(data["tags"])
+    else:
+        raise DeserializationError("ListTagsForResourceResponse.tags required")
+    return out

capo_devops_agent/types/list_webhooks_input.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListWebhooksInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.agent_space_id
+    import capo_devops_agent.types.association_id
+
+
+class ListWebhooksInput(TypedDict, closed=True):
+    agent_space_id: "capo_devops_agent.types.agent_space_id.AgentSpaceId"
+    """<p>The unique identifier of the AgentSpace</p>"""
+    association_id: "capo_devops_agent.types.association_id.AssociationId"
+    """<p>The unique identifier of the given association.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebhooksInput) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebhooksInput:
+    out: ListWebhooksInput = {}  # type: ignore[typeddict-item]
+    return out

capo_devops_agent/types/list_webhooks_output.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ListWebhooksOutput``."""
+
+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.webhooks_list
+
+
+class ListWebhooksOutput(TypedDict, closed=True):
+    webhooks: "capo_devops_agent.types.webhooks_list.WebhooksList"
+    """<p>The list of association webhooks.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebhooksOutput) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.webhooks_list
+
+    out["webhooks"] = capo_devops_agent.types.webhooks_list.serialize_json(
+        value["webhooks"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebhooksOutput:
+    out: ListWebhooksOutput = {}  # type: ignore[typeddict-item]
+    if data.get("webhooks") is not None:
+        import capo_devops_agent.types.webhooks_list
+
+        out["webhooks"] = capo_devops_agent.types.webhooks_list.deserialize_json(
+            data["webhooks"]
+        )
+    else:
+        raise DeserializationError("ListWebhooksOutput.webhooks required")
+    return out

capo_devops_agent/types/locale.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Locale``."""
+
+from typing import TypeAlias
+
+"""<p>A BCP 47 locale identifier for configuring the language used in agent responses.</p>"""
+Locale: TypeAlias = str

capo_devops_agent/types/max_ipv4_addresses_per_eni.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MaxIpv4AddressesPerEni``."""
+
+from typing import TypeAlias
+
+"""<p>The number of IPv4 addresses in each ENI for the Resource Gateway.</p>"""
+MaxIpv4AddressesPerEni: TypeAlias = int

capo_devops_agent/types/mcp_server_api_key_config.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerAPIKeyConfig``."""
+
+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.api_key_value
+
+
+class MCPServerAPIKeyConfig(TypedDict, closed=True):
+    api_key_name: "str"
+    """<p>User friendly API key name specified by end user.</p>"""
+    api_key_value: "capo_devops_agent.types.api_key_value.ApiKeyValue"
+    """<p>API key value for authenticating with the service.</p>"""
+    api_key_header: "str"
+    """<p>HTTP header name to send the API key in requests to the service.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerAPIKeyConfig) -> dict:
+    out: dict = {}
+    out["apiKeyName"] = value["api_key_name"]
+    out["apiKeyValue"] = value["api_key_value"]
+    out["apiKeyHeader"] = value["api_key_header"]
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerAPIKeyConfig:
+    out: MCPServerAPIKeyConfig = {}  # type: ignore[typeddict-item]
+    if data.get("apiKeyName") is not None:
+        out["api_key_name"] = data["apiKeyName"]
+    else:
+        raise DeserializationError("MCPServerAPIKeyConfig.api_key_name required")
+    if data.get("apiKeyValue") is not None:
+        out["api_key_value"] = data["apiKeyValue"]
+    else:
+        raise DeserializationError("MCPServerAPIKeyConfig.api_key_value required")
+    if data.get("apiKeyHeader") is not None:
+        out["api_key_header"] = data["apiKeyHeader"]
+    else:
+        raise DeserializationError("MCPServerAPIKeyConfig.api_key_header required")
+    return out