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

capo_devops_agent/types/mcp_server_sig_v4_authorization_config.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerSigV4AuthorizationConfig``."""
+
+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.role_arn
+    import capo_devops_agent.types.sig_v4_region
+
+
+class MCPServerSigV4AuthorizationConfig(TypedDict, closed=True):
+    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>Deprecated — use mcpRoleArn instead. IAM role ARN to assume for SigV4 signing.</p>"""
+    mcp_role_arn: NotRequired["capo_devops_agent.types.role_arn.RoleArn"]
+    """<p>IAM role ARN to assume for SigV4 signing. Optional — when omitted, credentials are resolved at runtime via a monitor account association.</p>"""
+    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: MCPServerSigV4AuthorizationConfig) -> dict:
+    out: dict = {}
+    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) -> MCPServerSigV4AuthorizationConfig:
+    out: MCPServerSigV4AuthorizationConfig = {}  # type: ignore[typeddict-item]
+    if data.get("region") is not None:
+        out["region"] = data["region"]
+    else:
+        raise DeserializationError("MCPServerSigV4AuthorizationConfig.region required")
+    if data.get("service") is not None:
+        out["service"] = data["service"]
+    else:
+        raise DeserializationError("MCPServerSigV4AuthorizationConfig.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/mcp_server_sig_v4_configuration.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerSigV4Configuration``."""
+
+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 MCPServerSigV4Configuration(TypedDict, closed=True):
+    tools: "capo_devops_agent.types.mcp_tools_list.MCPToolsList"
+    """<p>List of MCP tools available for the association.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerSigV4Configuration) -> 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) -> MCPServerSigV4Configuration:
+    out: MCPServerSigV4Configuration = {}  # 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("MCPServerSigV4Configuration.tools required")
+    return out

capo_devops_agent/types/mcp_server_sig_v4_service_details.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MCPServerSigV4ServiceDetails``."""
+
+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_endpoint
+    import capo_devops_agent.types.mcp_server_name
+    import capo_devops_agent.types.mcp_server_sig_v4_authorization_config
+
+
+class MCPServerSigV4ServiceDetails(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_sig_v4_authorization_config.MCPServerSigV4AuthorizationConfig"
+    """<p>MCP Server SigV4 authorization configuration.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: MCPServerSigV4ServiceDetails) -> 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_sig_v4_authorization_config
+
+    out["authorizationConfig"] = (
+        capo_devops_agent.types.mcp_server_sig_v4_authorization_config.serialize_json(
+            value["authorization_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> MCPServerSigV4ServiceDetails:
+    out: MCPServerSigV4ServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("MCPServerSigV4ServiceDetails.name required")
+    if data.get("endpoint") is not None:
+        out["endpoint"] = data["endpoint"]
+    else:
+        raise DeserializationError("MCPServerSigV4ServiceDetails.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_sig_v4_authorization_config
+
+        out["authorization_config"] = (
+            capo_devops_agent.types.mcp_server_sig_v4_authorization_config.deserialize_json(
+                data["authorizationConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "MCPServerSigV4ServiceDetails.authorization_config required"
+        )
+    return out

capo_devops_agent/types/mcp_server_splunk_configuration.py

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

capo_devops_agent/types/mcp_tools_list.py

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

capo_devops_agent/types/message.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#Message``."""
+
+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.assistant_message
+    import capo_devops_agent.types.user_message
+
+
+class _Message_userMessage(TypedDict, closed=True):
+    userMessage: "capo_devops_agent.types.user_message.UserMessage"
+
+
+class _Message_assistantMessage(TypedDict, closed=True):
+    assistantMessage: "capo_devops_agent.types.assistant_message.AssistantMessage"
+
+
+Message: TypeAlias = _Message_userMessage | _Message_assistantMessage
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Message) -> dict:
+    if "userMessage" in value:
+        import capo_devops_agent.types.user_message
+
+        return {
+            "userMessage": capo_devops_agent.types.user_message.serialize_json(
+                value["userMessage"]
+            )
+        }
+    elif "assistantMessage" in value:
+        import capo_devops_agent.types.assistant_message
+
+        return {
+            "assistantMessage": capo_devops_agent.types.assistant_message.serialize_json(
+                value["assistantMessage"]
+            )
+        }
+    else:
+        raise SerializationError("Message: no variant present")
+
+
+def deserialize_json(data: dict) -> Message:
+    if data.get("userMessage") is not None:
+        import capo_devops_agent.types.user_message
+
+        return {
+            "userMessage": capo_devops_agent.types.user_message.deserialize_json(
+                data["userMessage"]
+            )
+        }
+    elif data.get("assistantMessage") is not None:
+        import capo_devops_agent.types.assistant_message
+
+        return {
+            "assistantMessage": capo_devops_agent.types.assistant_message.deserialize_json(
+                data["assistantMessage"]
+            )
+        }
+    else:
+        raise DeserializationError("Message: no recognized variant key")

capo_devops_agent/types/message_content.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#MessageContent``."""
+
+from typing import TypeAlias
+
+"""<p>Message content with size constraint</p>"""
+MessageContent: TypeAlias = str

capo_devops_agent/types/monitor_account_type.py

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

capo_devops_agent/types/new_relic_alert_policy_ids.py

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

capo_devops_agent/types/new_relic_api_key_config.py

@@ -0,0 +1,117 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#NewRelicApiKeyConfig``."""
+
+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.api_key_value
+    import capo_devops_agent.types.new_relic_alert_policy_ids
+    import capo_devops_agent.types.new_relic_application_ids
+    import capo_devops_agent.types.new_relic_entity_guids
+    import capo_devops_agent.types.new_relic_region
+
+
+class NewRelicApiKeyConfig(TypedDict, closed=True):
+    api_key: "capo_devops_agent.types.api_key_value.ApiKeyValue"
+    """<p>New Relic User API Key</p>"""
+    account_id: "str"
+    """<p>New Relic Account ID</p>"""
+    region: "capo_devops_agent.types.new_relic_region.NewRelicRegion"
+    """<p>New Relic region (US or EU)</p>"""
+    application_ids: NotRequired[
+        "capo_devops_agent.types.new_relic_application_ids.NewRelicApplicationIds"
+    ]
+    """<p>List of monitored APM application IDs in New Relic</p>"""
+    entity_guids: NotRequired[
+        "capo_devops_agent.types.new_relic_entity_guids.NewRelicEntityGuids"
+    ]
+    """<p>List of globally unique IDs for New Relic resources (apps, hosts, services)</p>"""
+    alert_policy_ids: NotRequired[
+        "capo_devops_agent.types.new_relic_alert_policy_ids.NewRelicAlertPolicyIds"
+    ]
+    """<p>List of alert policy IDs grouping related conditions</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: NewRelicApiKeyConfig) -> dict:
+    out: dict = {}
+    out["apiKey"] = value["api_key"]
+    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 "application_ids" in value:
+        import capo_devops_agent.types.new_relic_application_ids
+
+        out["applicationIds"] = (
+            capo_devops_agent.types.new_relic_application_ids.serialize_json(
+                value["application_ids"]
+            )
+        )
+    if "entity_guids" in value:
+        import capo_devops_agent.types.new_relic_entity_guids
+
+        out["entityGuids"] = (
+            capo_devops_agent.types.new_relic_entity_guids.serialize_json(
+                value["entity_guids"]
+            )
+        )
+    if "alert_policy_ids" in value:
+        import capo_devops_agent.types.new_relic_alert_policy_ids
+
+        out["alertPolicyIds"] = (
+            capo_devops_agent.types.new_relic_alert_policy_ids.serialize_json(
+                value["alert_policy_ids"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> NewRelicApiKeyConfig:
+    out: NewRelicApiKeyConfig = {}  # type: ignore[typeddict-item]
+    if data.get("apiKey") is not None:
+        out["api_key"] = data["apiKey"]
+    else:
+        raise DeserializationError("NewRelicApiKeyConfig.api_key required")
+    if data.get("accountId") is not None:
+        out["account_id"] = data["accountId"]
+    else:
+        raise DeserializationError("NewRelicApiKeyConfig.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("NewRelicApiKeyConfig.region required")
+    if data.get("applicationIds") is not None:
+        import capo_devops_agent.types.new_relic_application_ids
+
+        out["application_ids"] = (
+            capo_devops_agent.types.new_relic_application_ids.deserialize_json(
+                data["applicationIds"]
+            )
+        )
+    if data.get("entityGuids") is not None:
+        import capo_devops_agent.types.new_relic_entity_guids
+
+        out["entity_guids"] = (
+            capo_devops_agent.types.new_relic_entity_guids.deserialize_json(
+                data["entityGuids"]
+            )
+        )
+    if data.get("alertPolicyIds") is not None:
+        import capo_devops_agent.types.new_relic_alert_policy_ids
+
+        out["alert_policy_ids"] = (
+            capo_devops_agent.types.new_relic_alert_policy_ids.deserialize_json(
+                data["alertPolicyIds"]
+            )
+        )
+    return out

capo_devops_agent/types/new_relic_application_ids.py

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

capo_devops_agent/types/new_relic_entity_guids.py

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

capo_devops_agent/types/new_relic_region.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#NewRelicRegion``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>The NewRelic region (determines API endpoint).</p>"""
+NewRelicRegion: TypeAlias = Literal[
+    "US",
+    "EU",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: NewRelicRegion) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> NewRelicRegion:
+    return cast(NewRelicRegion, data)

capo_devops_agent/types/new_relic_service_authorization_config.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#NewRelicServiceAuthorizationConfig``."""
+
+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.new_relic_api_key_config
+
+
+class _NewRelicServiceAuthorizationConfig_apiKey(TypedDict, closed=True):
+    apiKey: "capo_devops_agent.types.new_relic_api_key_config.NewRelicApiKeyConfig"
+
+
+NewRelicServiceAuthorizationConfig: TypeAlias = (
+    _NewRelicServiceAuthorizationConfig_apiKey
+)
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: NewRelicServiceAuthorizationConfig) -> dict:
+    if "apiKey" in value:
+        import capo_devops_agent.types.new_relic_api_key_config
+
+        return {
+            "apiKey": capo_devops_agent.types.new_relic_api_key_config.serialize_json(
+                value["apiKey"]
+            )
+        }
+    else:
+        raise SerializationError(
+            "NewRelicServiceAuthorizationConfig: no variant present"
+        )
+
+
+def deserialize_json(data: dict) -> NewRelicServiceAuthorizationConfig:
+    if data.get("apiKey") is not None:
+        import capo_devops_agent.types.new_relic_api_key_config
+
+        return {
+            "apiKey": capo_devops_agent.types.new_relic_api_key_config.deserialize_json(
+                data["apiKey"]
+            )
+        }
+    else:
+        raise DeserializationError(
+            "NewRelicServiceAuthorizationConfig: no recognized variant key"
+        )

capo_devops_agent/types/new_relic_service_details.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#NewRelicServiceDetails``."""
+
+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.new_relic_service_authorization_config
+
+
+class NewRelicServiceDetails(TypedDict, closed=True):
+    authorization_config: "capo_devops_agent.types.new_relic_service_authorization_config.NewRelicServiceAuthorizationConfig"
+    """<p>New Relic MCP server authorization configuration.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: NewRelicServiceDetails) -> dict:
+    out: dict = {}
+    import capo_devops_agent.types.new_relic_service_authorization_config
+
+    out["authorizationConfig"] = (
+        capo_devops_agent.types.new_relic_service_authorization_config.serialize_json(
+            value["authorization_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> NewRelicServiceDetails:
+    out: NewRelicServiceDetails = {}  # type: ignore[typeddict-item]
+    if data.get("authorizationConfig") is not None:
+        import capo_devops_agent.types.new_relic_service_authorization_config
+
+        out["authorization_config"] = (
+            capo_devops_agent.types.new_relic_service_authorization_config.deserialize_json(
+                data["authorizationConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "NewRelicServiceDetails.authorization_config required"
+        )
+    return out

capo_devops_agent/types/next_token.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#NextToken``."""
+
+from typing import TypeAlias
+
+"""<p>Pagination token for list operations (1-2048 characters)</p>"""
+NextToken: TypeAlias = str

capo_devops_agent/types/o_auth_additional_step_details.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#OAuthAdditionalStepDetails``."""
+
+from typing_extensions import TypedDict
+
+from capo_devops_agent.errors import DeserializationError
+
+
+class OAuthAdditionalStepDetails(TypedDict, closed=True):
+    authorization_url: "str"
+    """<p>The URL to redirect the user to for OAuth authorization.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: OAuthAdditionalStepDetails) -> dict:
+    out: dict = {}
+    out["authorizationUrl"] = value["authorization_url"]
+    return out
+
+
+def deserialize_json(data: dict) -> OAuthAdditionalStepDetails:
+    out: OAuthAdditionalStepDetails = {}  # type: ignore[typeddict-item]
+    if data.get("authorizationUrl") is not None:
+        out["authorization_url"] = data["authorizationUrl"]
+    else:
+        raise DeserializationError(
+            "OAuthAdditionalStepDetails.authorization_url required"
+        )
+    return out

capo_devops_agent/types/o_auth_scope.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#OAuthScope``."""
+
+from typing import TypeAlias
+
+"""<p>OAuth scope parameter</p>"""
+OAuthScope: TypeAlias = str

capo_devops_agent/types/operator_app_url.py

@@ -0,0 +1,6 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#OperatorAppUrl``."""
+
+from typing import TypeAlias
+
+"""<p>The URL for operators to access the Operator App.</p>"""
+OperatorAppUrl: TypeAlias = str

capo_devops_agent/types/order_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.devopsagent#OrderType``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>Sort order options for journal operations</p>"""
+OrderType: TypeAlias = Literal[
+    "ASC",
+    "DESC",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: OrderType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> OrderType:
+    return cast(OrderType, data)