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

capo_devops_agent/types/enable_operator_app_output.py

@@ -0,0 +1,88 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#EnableOperatorAppOutput``."""
+
+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.agent_space_id
+    import capo_devops_agent.types.iam_auth_configuration
+    import capo_devops_agent.types.idc_auth_configuration
+    import capo_devops_agent.types.idp_auth_configuration
+    import capo_devops_agent.types.operator_app_url
+
+
+class EnableOperatorAppOutput(TypedDict, closed=True):
+    agent_space_id: "capo_devops_agent.types.agent_space_id.AgentSpaceId"
+    """<p>The unique identifier of the AgentSpace</p>"""
+    operator_app_url: NotRequired[
+        "capo_devops_agent.types.operator_app_url.OperatorAppUrl"
+    ]
+    """<p>The URL for operators to access the Operator App</p>"""
+    iam: NotRequired[
+        "capo_devops_agent.types.iam_auth_configuration.IamAuthConfiguration"
+    ]
+    idc: NotRequired[
+        "capo_devops_agent.types.idc_auth_configuration.IdcAuthConfiguration"
+    ]
+    idp: NotRequired[
+        "capo_devops_agent.types.idp_auth_configuration.IdpAuthConfiguration"
+    ]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EnableOperatorAppOutput) -> dict:
+    out: dict = {}
+    out["agentSpaceId"] = value["agent_space_id"]
+    if "operator_app_url" in value:
+        out["operatorAppUrl"] = value["operator_app_url"]
+    if "iam" in value:
+        import capo_devops_agent.types.iam_auth_configuration
+
+        out["iam"] = capo_devops_agent.types.iam_auth_configuration.serialize_json(
+            value["iam"]
+        )
+    if "idc" in value:
+        import capo_devops_agent.types.idc_auth_configuration
+
+        out["idc"] = capo_devops_agent.types.idc_auth_configuration.serialize_json(
+            value["idc"]
+        )
+    if "idp" in value:
+        import capo_devops_agent.types.idp_auth_configuration
+
+        out["idp"] = capo_devops_agent.types.idp_auth_configuration.serialize_json(
+            value["idp"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> EnableOperatorAppOutput:
+    out: EnableOperatorAppOutput = {}  # type: ignore[typeddict-item]
+    if data.get("agentSpaceId") is not None:
+        out["agent_space_id"] = data["agentSpaceId"]
+    else:
+        raise DeserializationError("EnableOperatorAppOutput.agent_space_id required")
+    if data.get("operatorAppUrl") is not None:
+        out["operator_app_url"] = data["operatorAppUrl"]
+    if data.get("iam") is not None:
+        import capo_devops_agent.types.iam_auth_configuration
+
+        out["iam"] = capo_devops_agent.types.iam_auth_configuration.deserialize_json(
+            data["iam"]
+        )
+    if data.get("idc") is not None:
+        import capo_devops_agent.types.idc_auth_configuration
+
+        out["idc"] = capo_devops_agent.types.idc_auth_configuration.deserialize_json(
+            data["idc"]
+        )
+    if data.get("idp") is not None:
+        import capo_devops_agent.types.idp_auth_configuration
+
+        out["idp"] = capo_devops_agent.types.idp_auth_configuration.deserialize_json(
+            data["idp"]
+        )
+    return out

capo_devops_agent/types/event_channel_configuration.py

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

capo_devops_agent/types/event_channel_details.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#EventChannelDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.event_channel_type
+
+
+class EventChannelDetails(TypedDict, closed=True):
+    type: NotRequired["capo_devops_agent.types.event_channel_type.EventChannelType"]
+    """<p>The type of event channel</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EventChannelDetails) -> dict:
+    out: dict = {}
+    if "type" in value:
+        import capo_devops_agent.types.event_channel_type
+
+        out["type"] = capo_devops_agent.types.event_channel_type.serialize_json(
+            value["type"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> EventChannelDetails:
+    out: EventChannelDetails = {}  # type: ignore[typeddict-item]
+    if data.get("type") is not None:
+        import capo_devops_agent.types.event_channel_type
+
+        out["type"] = capo_devops_agent.types.event_channel_type.deserialize_json(
+            data["type"]
+        )
+    return out

capo_devops_agent/types/event_channel_type.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#EventChannelType``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Event Channel type</p>"""
+EventChannelType: TypeAlias = Literal["webhook",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EventChannelType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> EventChannelType:
+    return cast(EventChannelType, data)

capo_devops_agent/types/exchange_parameter_value.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ExchangeParameterValue``."""
+
+from typing import TypeAlias
+
+"""<p>Exchange Parameter value for MCP authentication</p>"""
+ExchangeParameterValue: TypeAlias = str

capo_devops_agent/types/exchange_parameters.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ExchangeParameters``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.exchange_parameter_value
+
+ExchangeParameters: TypeAlias = dict[
+    "str", "capo_devops_agent.types.exchange_parameter_value.ExchangeParameterValue"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: ExchangeParameters) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_json(data: dict) -> ExchangeParameters:
+    out: ExchangeParameters = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        out[key] = value
+    return out

capo_devops_agent/types/execution.py

@@ -0,0 +1,111 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Execution``."""
+
+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.execution_status
+    import capo_devops_agent.types.journal_timestamp
+
+
+class Execution(TypedDict, closed=True):
+    agent_space_id: "str"
+    """<p>The unique identifier for the agent space containing this execution</p>"""
+    execution_id: "str"
+    """<p>The unique identifier for this execution</p>"""
+    parent_execution_id: NotRequired["str"]
+    """<p>The identifier of the parent execution, if this is a child execution</p>"""
+    agent_sub_task: "str"
+    """<p>The specific subtask being executed by the agent</p>"""
+    created_at: "capo_devops_agent.types.journal_timestamp.JournalTimestamp"
+    """<p>Timestamp when this execution was created</p>"""
+    updated_at: "capo_devops_agent.types.journal_timestamp.JournalTimestamp"
+    """<p>Timestamp when this execution was last updated</p>"""
+    execution_status: "capo_devops_agent.types.execution_status.ExecutionStatus"
+    """<p>The current status of this execution</p>"""
+    agent_type: NotRequired["str"]
+    """<p>The type of agent that performed this execution.</p>"""
+    uid: NotRequired["str"]
+    """<p>The unique identifier for the user session associated with this execution</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Execution) -> dict:
+    out: dict = {}
+    out["agentSpaceId"] = value["agent_space_id"]
+    out["executionId"] = value["execution_id"]
+    if "parent_execution_id" in value:
+        out["parentExecutionId"] = value["parent_execution_id"]
+    out["agentSubTask"] = value["agent_sub_task"]
+    import capo_devops_agent.types.journal_timestamp
+
+    out["createdAt"] = capo_devops_agent.types.journal_timestamp.serialize_json(
+        value["created_at"]
+    )
+    import capo_devops_agent.types.journal_timestamp
+
+    out["updatedAt"] = capo_devops_agent.types.journal_timestamp.serialize_json(
+        value["updated_at"]
+    )
+    import capo_devops_agent.types.execution_status
+
+    out["executionStatus"] = capo_devops_agent.types.execution_status.serialize_json(
+        value["execution_status"]
+    )
+    if "agent_type" in value:
+        out["agentType"] = value["agent_type"]
+    if "uid" in value:
+        out["uid"] = value["uid"]
+    return out
+
+
+def deserialize_json(data: dict) -> Execution:
+    out: Execution = {}  # type: ignore[typeddict-item]
+    if data.get("agentSpaceId") is not None:
+        out["agent_space_id"] = data["agentSpaceId"]
+    else:
+        raise DeserializationError("Execution.agent_space_id required")
+    if data.get("executionId") is not None:
+        out["execution_id"] = data["executionId"]
+    else:
+        raise DeserializationError("Execution.execution_id required")
+    if data.get("parentExecutionId") is not None:
+        out["parent_execution_id"] = data["parentExecutionId"]
+    if data.get("agentSubTask") is not None:
+        out["agent_sub_task"] = data["agentSubTask"]
+    else:
+        raise DeserializationError("Execution.agent_sub_task required")
+    if data.get("createdAt") is not None:
+        import capo_devops_agent.types.journal_timestamp
+
+        out["created_at"] = capo_devops_agent.types.journal_timestamp.deserialize_json(
+            data["createdAt"]
+        )
+    else:
+        raise DeserializationError("Execution.created_at required")
+    if data.get("updatedAt") is not None:
+        import capo_devops_agent.types.journal_timestamp
+
+        out["updated_at"] = capo_devops_agent.types.journal_timestamp.deserialize_json(
+            data["updatedAt"]
+        )
+    else:
+        raise DeserializationError("Execution.updated_at required")
+    if data.get("executionStatus") is not None:
+        import capo_devops_agent.types.execution_status
+
+        out["execution_status"] = (
+            capo_devops_agent.types.execution_status.deserialize_json(
+                data["executionStatus"]
+            )
+        )
+    else:
+        raise DeserializationError("Execution.execution_status required")
+    if data.get("agentType") is not None:
+        out["agent_type"] = data["agentType"]
+    if data.get("uid") is not None:
+        out["uid"] = data["uid"]
+    return out

capo_devops_agent/types/execution_list.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ExecutionList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.execution
+
+ExecutionList: TypeAlias = list["capo_devops_agent.types.execution.Execution"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionList) -> list:
+    import capo_devops_agent.types.execution
+
+    out: list = []
+    for item in value:
+        out.append(capo_devops_agent.types.execution.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> ExecutionList:
+    import capo_devops_agent.types.execution
+
+    out: ExecutionList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_devops_agent.types.execution.deserialize_json(item))
+    return out

capo_devops_agent/types/execution_status.py

@@ -0,0 +1,21 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#ExecutionStatus``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Possible states of an execution</p>"""
+ExecutionStatus: TypeAlias = Literal[
+    "FAILED",
+    "RUNNING",
+    "STOPPED",
+    "CANCELED",
+    "TIMED_OUT",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionStatus) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> ExecutionStatus:
+    return cast(ExecutionStatus, data)

capo_devops_agent/types/failure_message.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#FailureMessage``."""
+
+from typing import TypeAlias
+
+"""<p>Failure message describing why a Private Connection has a FAILED status.</p>"""
+FailureMessage: TypeAlias = str

capo_devops_agent/types/generic_webhook.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GenericWebhook``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_devops_agent.types.api_key_value
+    import capo_devops_agent.types.webhook_secret
+    import capo_devops_agent.types.webhook_type
+
+
+class GenericWebhook(TypedDict, closed=True):
+    webhook_url: NotRequired["str"]
+    """<p>The webhook URL endpoint</p>"""
+    webhook_id: NotRequired["str"]
+    """<p>The unique webhook identifier</p>"""
+    webhook_type: NotRequired["capo_devops_agent.types.webhook_type.WebhookType"]
+    """<p>The webhook authentication type</p>"""
+    webhook_secret: NotRequired["capo_devops_agent.types.webhook_secret.WebhookSecret"]
+    """<p>The webhook secret for authentication</p>"""
+    api_key: NotRequired["capo_devops_agent.types.api_key_value.ApiKeyValue"]
+    """<p>API Key for API Key webhook authentication</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GenericWebhook) -> dict:
+    out: dict = {}
+    if "webhook_url" in value:
+        out["webhookUrl"] = value["webhook_url"]
+    if "webhook_id" in value:
+        out["webhookId"] = value["webhook_id"]
+    if "webhook_type" in value:
+        import capo_devops_agent.types.webhook_type
+
+        out["webhookType"] = capo_devops_agent.types.webhook_type.serialize_json(
+            value["webhook_type"]
+        )
+    if "webhook_secret" in value:
+        out["webhookSecret"] = value["webhook_secret"]
+    if "api_key" in value:
+        out["apiKey"] = value["api_key"]
+    return out
+
+
+def deserialize_json(data: dict) -> GenericWebhook:
+    out: GenericWebhook = {}  # type: ignore[typeddict-item]
+    if data.get("webhookUrl") is not None:
+        out["webhook_url"] = data["webhookUrl"]
+    if data.get("webhookId") is not None:
+        out["webhook_id"] = data["webhookId"]
+    if data.get("webhookType") is not None:
+        import capo_devops_agent.types.webhook_type
+
+        out["webhook_type"] = capo_devops_agent.types.webhook_type.deserialize_json(
+            data["webhookType"]
+        )
+    if data.get("webhookSecret") is not None:
+        out["webhook_secret"] = data["webhookSecret"]
+    if data.get("apiKey") is not None:
+        out["api_key"] = data["apiKey"]
+    return out

capo_devops_agent/types/get_account_usage_input.py

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

capo_devops_agent/types/get_account_usage_output.py

@@ -0,0 +1,143 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#GetAccountUsageOutput``."""
+
+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.date_time
+    import capo_devops_agent.types.usage_metric
+
+
+class GetAccountUsageOutput(TypedDict, closed=True):
+    monthly_account_investigation_hours: NotRequired[
+        "capo_devops_agent.types.usage_metric.UsageMetric"
+    ]
+    """<p>Monthly investigation hours usage and limit for an account</p>"""
+    monthly_account_evaluation_hours: NotRequired[
+        "capo_devops_agent.types.usage_metric.UsageMetric"
+    ]
+    """<p>Monthly evaluation hours usage and limit for an account</p>"""
+    monthly_account_system_learning_hours: NotRequired[
+        "capo_devops_agent.types.usage_metric.UsageMetric"
+    ]
+    """<p>Monthly system learning hours usage and limit for an account</p>"""
+    monthly_account_on_demand_hours: NotRequired[
+        "capo_devops_agent.types.usage_metric.UsageMetric"
+    ]
+    """<p>Monthly on-demand hours usage and limit for an account</p>"""
+    usage_period_start_time: "capo_devops_agent.types.date_time.DateTime"
+    """<p>The start time of the usage tracking period</p>"""
+    usage_period_end_time: "capo_devops_agent.types.date_time.DateTime"
+    """<p>The end time of the usage tracking period</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAccountUsageOutput) -> dict:
+    out: dict = {}
+    if "monthly_account_investigation_hours" in value:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthlyAccountInvestigationHours"] = (
+            capo_devops_agent.types.usage_metric.serialize_json(
+                value["monthly_account_investigation_hours"]
+            )
+        )
+    if "monthly_account_evaluation_hours" in value:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthlyAccountEvaluationHours"] = (
+            capo_devops_agent.types.usage_metric.serialize_json(
+                value["monthly_account_evaluation_hours"]
+            )
+        )
+    if "monthly_account_system_learning_hours" in value:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthlyAccountSystemLearningHours"] = (
+            capo_devops_agent.types.usage_metric.serialize_json(
+                value["monthly_account_system_learning_hours"]
+            )
+        )
+    if "monthly_account_on_demand_hours" in value:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthlyAccountOnDemandHours"] = (
+            capo_devops_agent.types.usage_metric.serialize_json(
+                value["monthly_account_on_demand_hours"]
+            )
+        )
+    import capo_devops_agent.types.date_time
+
+    out["usagePeriodStartTime"] = capo_devops_agent.types.date_time.serialize_json(
+        value["usage_period_start_time"]
+    )
+    import capo_devops_agent.types.date_time
+
+    out["usagePeriodEndTime"] = capo_devops_agent.types.date_time.serialize_json(
+        value["usage_period_end_time"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetAccountUsageOutput:
+    out: GetAccountUsageOutput = {}  # type: ignore[typeddict-item]
+    if data.get("monthlyAccountInvestigationHours") is not None:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthly_account_investigation_hours"] = (
+            capo_devops_agent.types.usage_metric.deserialize_json(
+                data["monthlyAccountInvestigationHours"]
+            )
+        )
+    if data.get("monthlyAccountEvaluationHours") is not None:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthly_account_evaluation_hours"] = (
+            capo_devops_agent.types.usage_metric.deserialize_json(
+                data["monthlyAccountEvaluationHours"]
+            )
+        )
+    if data.get("monthlyAccountSystemLearningHours") is not None:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthly_account_system_learning_hours"] = (
+            capo_devops_agent.types.usage_metric.deserialize_json(
+                data["monthlyAccountSystemLearningHours"]
+            )
+        )
+    if data.get("monthlyAccountOnDemandHours") is not None:
+        import capo_devops_agent.types.usage_metric
+
+        out["monthly_account_on_demand_hours"] = (
+            capo_devops_agent.types.usage_metric.deserialize_json(
+                data["monthlyAccountOnDemandHours"]
+            )
+        )
+    if data.get("usagePeriodStartTime") is not None:
+        import capo_devops_agent.types.date_time
+
+        out["usage_period_start_time"] = (
+            capo_devops_agent.types.date_time.deserialize_json(
+                data["usagePeriodStartTime"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetAccountUsageOutput.usage_period_start_time required"
+        )
+    if data.get("usagePeriodEndTime") is not None:
+        import capo_devops_agent.types.date_time
+
+        out["usage_period_end_time"] = (
+            capo_devops_agent.types.date_time.deserialize_json(
+                data["usagePeriodEndTime"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetAccountUsageOutput.usage_period_end_time required"
+        )
+    return out

capo_devops_agent/types/get_agent_space_input.py

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

capo_devops_agent/types/get_agent_space_output.py

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