capo-codecatalyst 0.1.0__py3-none-any.whl

capo_codecatalyst/types/dev_environment_sessions_summary_list.py

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

capo_codecatalyst/types/dev_environment_status.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#DevEnvironmentStatus``."""
+
+from typing import TypeAlias
+
+DevEnvironmentStatus: TypeAlias = str

capo_codecatalyst/types/dev_environment_summary.py

@@ -0,0 +1,163 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#DevEnvironmentSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.dev_environment_repository_summaries
+    import capo_codecatalyst.types.dev_environment_status
+    import capo_codecatalyst.types.ides
+    import capo_codecatalyst.types.inactivity_timeout_minutes
+    import capo_codecatalyst.types.instance_type
+    import capo_codecatalyst.types.name_string
+    import capo_codecatalyst.types.persistent_storage
+    import capo_codecatalyst.types.status_reason
+    import capo_codecatalyst.types.timestamp
+    import capo_codecatalyst.types.uuid
+
+
+class DevEnvironmentSummary(TypedDict, closed=True):
+    space_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The name of the space.</p>"""
+    project_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The name of the project in the space.</p>"""
+    id: "capo_codecatalyst.types.uuid.Uuid"
+    """<p>The system-generated unique ID for the Dev Environment. </p>"""
+    last_updated_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time when the Dev Environment was last updated, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    creator_id: "str"
+    """<p>The system-generated unique ID of the user who created the Dev Environment. </p>"""
+    status: "capo_codecatalyst.types.dev_environment_status.DevEnvironmentStatus"
+    """<p>The status of the Dev Environment. </p>"""
+    status_reason: NotRequired["capo_codecatalyst.types.status_reason.StatusReason"]
+    """<p>The reason for the status.</p>"""
+    repositories: "capo_codecatalyst.types.dev_environment_repository_summaries.DevEnvironmentRepositorySummaries"
+    """<p>Information about the repositories that will be cloned into the Dev Environment. If no rvalue is specified, no repository is cloned.</p>"""
+    alias: NotRequired["str"]
+    """<p>The user-specified alias for the Dev Environment.</p>"""
+    ides: NotRequired["capo_codecatalyst.types.ides.Ides"]
+    """<p>Information about the integrated development environment (IDE) configured for a Dev Environment.</p>"""
+    instance_type: "capo_codecatalyst.types.instance_type.InstanceType"
+    """<p>The Amazon EC2 instace type used for the Dev Environment. </p>"""
+    inactivity_timeout_minutes: (
+        "capo_codecatalyst.types.inactivity_timeout_minutes.InactivityTimeoutMinutes"
+    )
+    """<p>The amount of time the Dev Environment will run without any activity detected before stopping, in minutes. Dev Environments consume compute minutes when running.</p>"""
+    persistent_storage: "capo_codecatalyst.types.persistent_storage.PersistentStorage"
+    """<p>Information about the configuration of persistent storage for the Dev Environment.</p>"""
+    vpc_connection_name: NotRequired["capo_codecatalyst.types.name_string.NameString"]
+    """<p>The name of the connection used to connect to Amazon VPC used when the Dev Environment was created, if any.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: DevEnvironmentSummary) -> dict:
+    out: dict = {}
+    if "space_name" in value:
+        out["spaceName"] = value["space_name"]
+    if "project_name" in value:
+        out["projectName"] = value["project_name"]
+    out["id"] = value["id"]
+    import capo_codecatalyst._protocol.serialize
+
+    out["lastUpdatedTime"] = capo_codecatalyst._protocol.serialize.fmt_date_time(
+        value["last_updated_time"]
+    )
+    out["creatorId"] = value["creator_id"]
+    out["status"] = value["status"]
+    if "status_reason" in value:
+        out["statusReason"] = value["status_reason"]
+    import capo_codecatalyst.types.dev_environment_repository_summaries
+
+    out["repositories"] = (
+        capo_codecatalyst.types.dev_environment_repository_summaries.serialize_json(
+            value["repositories"]
+        )
+    )
+    if "alias" in value:
+        out["alias"] = value["alias"]
+    if "ides" in value:
+        import capo_codecatalyst.types.ides
+
+        out["ides"] = capo_codecatalyst.types.ides.serialize_json(value["ides"])
+    out["instanceType"] = value["instance_type"]
+    out["inactivityTimeoutMinutes"] = value.get("inactivity_timeout_minutes", 0)
+    import capo_codecatalyst.types.persistent_storage
+
+    out["persistentStorage"] = (
+        capo_codecatalyst.types.persistent_storage.serialize_json(
+            value["persistent_storage"]
+        )
+    )
+    if "vpc_connection_name" in value:
+        out["vpcConnectionName"] = value["vpc_connection_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> DevEnvironmentSummary:
+    out: DevEnvironmentSummary = {}  # type: ignore[typeddict-item]
+    if data.get("spaceName") is not None:
+        out["space_name"] = data["spaceName"]
+    if data.get("projectName") is not None:
+        out["project_name"] = data["projectName"]
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    else:
+        raise DeserializationError("DevEnvironmentSummary.id required")
+    if data.get("lastUpdatedTime") is not None:
+        import datetime
+
+        out["last_updated_time"] = datetime.datetime.fromisoformat(
+            data["lastUpdatedTime"].replace("Z", "+00:00")
+        )
+    else:
+        raise DeserializationError("DevEnvironmentSummary.last_updated_time required")
+    if data.get("creatorId") is not None:
+        out["creator_id"] = data["creatorId"]
+    else:
+        raise DeserializationError("DevEnvironmentSummary.creator_id required")
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    else:
+        raise DeserializationError("DevEnvironmentSummary.status required")
+    if data.get("statusReason") is not None:
+        out["status_reason"] = data["statusReason"]
+    if data.get("repositories") is not None:
+        import capo_codecatalyst.types.dev_environment_repository_summaries
+
+        out["repositories"] = (
+            capo_codecatalyst.types.dev_environment_repository_summaries.deserialize_json(
+                data["repositories"]
+            )
+        )
+    else:
+        raise DeserializationError("DevEnvironmentSummary.repositories required")
+    if data.get("alias") is not None:
+        out["alias"] = data["alias"]
+    if data.get("ides") is not None:
+        import capo_codecatalyst.types.ides
+
+        out["ides"] = capo_codecatalyst.types.ides.deserialize_json(data["ides"])
+    if data.get("instanceType") is not None:
+        out["instance_type"] = data["instanceType"]
+    else:
+        raise DeserializationError("DevEnvironmentSummary.instance_type required")
+    if data.get("inactivityTimeoutMinutes") is not None:
+        out["inactivity_timeout_minutes"] = data["inactivityTimeoutMinutes"]
+    else:
+        out["inactivity_timeout_minutes"] = 0
+    if data.get("persistentStorage") is not None:
+        import capo_codecatalyst.types.persistent_storage
+
+        out["persistent_storage"] = (
+            capo_codecatalyst.types.persistent_storage.deserialize_json(
+                data["persistentStorage"]
+            )
+        )
+    else:
+        raise DeserializationError("DevEnvironmentSummary.persistent_storage required")
+    if data.get("vpcConnectionName") is not None:
+        out["vpc_connection_name"] = data["vpcConnectionName"]
+    return out

capo_codecatalyst/types/dev_environment_summary_list.py

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

capo_codecatalyst/types/email_address.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#EmailAddress``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class EmailAddress(TypedDict, closed=True):
+    email: NotRequired["str"]
+    """<p>The email address.</p>"""
+    verified: NotRequired["bool"]
+    """<p>Whether the email address has been verified.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EmailAddress) -> dict:
+    out: dict = {}
+    if "email" in value:
+        out["email"] = value["email"]
+    if "verified" in value:
+        out["verified"] = value["verified"]
+    return out
+
+
+def deserialize_json(data: dict) -> EmailAddress:
+    out: EmailAddress = {}  # type: ignore[typeddict-item]
+    if data.get("email") is not None:
+        out["email"] = data["email"]
+    if data.get("verified") is not None:
+        out["verified"] = data["verified"]
+    return out

capo_codecatalyst/types/event_log_entries.py

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

capo_codecatalyst/types/event_log_entry.py

@@ -0,0 +1,174 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#EventLogEntry``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.event_payload
+    import capo_codecatalyst.types.operation_type
+    import capo_codecatalyst.types.project_information
+    import capo_codecatalyst.types.timestamp
+    import capo_codecatalyst.types.user_identity
+
+
+class EventLogEntry(TypedDict, closed=True):
+    id: "str"
+    """<p>The system-generated unique ID of the event.</p>"""
+    event_name: "str"
+    """<p>The name of the event.</p>"""
+    event_type: "str"
+    """<p>The type of the event.</p>"""
+    event_category: "str"
+    """<p>The category for the event.</p>"""
+    event_source: "str"
+    """<p>The source of the event.</p>"""
+    event_time: "capo_codecatalyst.types.timestamp.Timestamp"
+    r"""<p>The time the event took place, in coordinated universal time (UTC) timestamp format as specified in <a href=\"https://www.rfc-editor.org/rfc/rfc3339#section-5.6\">RFC 3339</a>.</p>"""
+    operation_type: "capo_codecatalyst.types.operation_type.OperationType"
+    """<p>The type of the event.</p>"""
+    user_identity: "capo_codecatalyst.types.user_identity.UserIdentity"
+    """<p>The system-generated unique ID of the user whose actions are recorded in the event.</p>"""
+    project_information: NotRequired[
+        "capo_codecatalyst.types.project_information.ProjectInformation"
+    ]
+    """<p>Information about the project where the event occurred.</p>"""
+    request_id: NotRequired["str"]
+    """<p>The system-generated unique ID of the request.</p>"""
+    request_payload: NotRequired["capo_codecatalyst.types.event_payload.EventPayload"]
+    """<p>Information about the payload of the request.</p>"""
+    response_payload: NotRequired["capo_codecatalyst.types.event_payload.EventPayload"]
+    """<p>Information about the payload of the response, if any.</p>"""
+    error_code: NotRequired["str"]
+    """<p>The code of the error, if any.</p>"""
+    source_ip_address: NotRequired["str"]
+    """<p>The IP address of the user whose actions are recorded in the event.</p>"""
+    user_agent: NotRequired["str"]
+    """<p>The user agent whose actions are recorded in the event.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EventLogEntry) -> dict:
+    out: dict = {}
+    out["id"] = value["id"]
+    out["eventName"] = value["event_name"]
+    out["eventType"] = value["event_type"]
+    out["eventCategory"] = value["event_category"]
+    out["eventSource"] = value["event_source"]
+    import capo_codecatalyst._protocol.serialize
+
+    out["eventTime"] = capo_codecatalyst._protocol.serialize.fmt_date_time(
+        value["event_time"]
+    )
+    out["operationType"] = value["operation_type"]
+    import capo_codecatalyst.types.user_identity
+
+    out["userIdentity"] = capo_codecatalyst.types.user_identity.serialize_json(
+        value["user_identity"]
+    )
+    if "project_information" in value:
+        import capo_codecatalyst.types.project_information
+
+        out["projectInformation"] = (
+            capo_codecatalyst.types.project_information.serialize_json(
+                value["project_information"]
+            )
+        )
+    if "request_id" in value:
+        out["requestId"] = value["request_id"]
+    if "request_payload" in value:
+        import capo_codecatalyst.types.event_payload
+
+        out["requestPayload"] = capo_codecatalyst.types.event_payload.serialize_json(
+            value["request_payload"]
+        )
+    if "response_payload" in value:
+        import capo_codecatalyst.types.event_payload
+
+        out["responsePayload"] = capo_codecatalyst.types.event_payload.serialize_json(
+            value["response_payload"]
+        )
+    if "error_code" in value:
+        out["errorCode"] = value["error_code"]
+    if "source_ip_address" in value:
+        out["sourceIpAddress"] = value["source_ip_address"]
+    if "user_agent" in value:
+        out["userAgent"] = value["user_agent"]
+    return out
+
+
+def deserialize_json(data: dict) -> EventLogEntry:
+    out: EventLogEntry = {}  # type: ignore[typeddict-item]
+    if data.get("id") is not None:
+        out["id"] = data["id"]
+    else:
+        raise DeserializationError("EventLogEntry.id required")
+    if data.get("eventName") is not None:
+        out["event_name"] = data["eventName"]
+    else:
+        raise DeserializationError("EventLogEntry.event_name required")
+    if data.get("eventType") is not None:
+        out["event_type"] = data["eventType"]
+    else:
+        raise DeserializationError("EventLogEntry.event_type required")
+    if data.get("eventCategory") is not None:
+        out["event_category"] = data["eventCategory"]
+    else:
+        raise DeserializationError("EventLogEntry.event_category required")
+    if data.get("eventSource") is not None:
+        out["event_source"] = data["eventSource"]
+    else:
+        raise DeserializationError("EventLogEntry.event_source required")
+    if data.get("eventTime") is not None:
+        import datetime
+
+        out["event_time"] = datetime.datetime.fromisoformat(
+            data["eventTime"].replace("Z", "+00:00")
+        )
+    else:
+        raise DeserializationError("EventLogEntry.event_time required")
+    if data.get("operationType") is not None:
+        out["operation_type"] = data["operationType"]
+    else:
+        raise DeserializationError("EventLogEntry.operation_type required")
+    if data.get("userIdentity") is not None:
+        import capo_codecatalyst.types.user_identity
+
+        out["user_identity"] = capo_codecatalyst.types.user_identity.deserialize_json(
+            data["userIdentity"]
+        )
+    else:
+        raise DeserializationError("EventLogEntry.user_identity required")
+    if data.get("projectInformation") is not None:
+        import capo_codecatalyst.types.project_information
+
+        out["project_information"] = (
+            capo_codecatalyst.types.project_information.deserialize_json(
+                data["projectInformation"]
+            )
+        )
+    if data.get("requestId") is not None:
+        out["request_id"] = data["requestId"]
+    if data.get("requestPayload") is not None:
+        import capo_codecatalyst.types.event_payload
+
+        out["request_payload"] = capo_codecatalyst.types.event_payload.deserialize_json(
+            data["requestPayload"]
+        )
+    if data.get("responsePayload") is not None:
+        import capo_codecatalyst.types.event_payload
+
+        out["response_payload"] = (
+            capo_codecatalyst.types.event_payload.deserialize_json(
+                data["responsePayload"]
+            )
+        )
+    if data.get("errorCode") is not None:
+        out["error_code"] = data["errorCode"]
+    if data.get("sourceIpAddress") is not None:
+        out["source_ip_address"] = data["sourceIpAddress"]
+    if data.get("userAgent") is not None:
+        out["user_agent"] = data["userAgent"]
+    return out

capo_codecatalyst/types/event_payload.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#EventPayload``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class EventPayload(TypedDict, closed=True):
+    content_type: NotRequired["str"]
+    """<p>The type of content in the event payload.</p>"""
+    data: NotRequired["str"]
+    """<p>The data included in the event payload.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EventPayload) -> dict:
+    out: dict = {}
+    if "content_type" in value:
+        out["contentType"] = value["content_type"]
+    if "data" in value:
+        out["data"] = value["data"]
+    return out
+
+
+def deserialize_json(data: dict) -> EventPayload:
+    out: EventPayload = {}  # type: ignore[typeddict-item]
+    if data.get("contentType") is not None:
+        out["content_type"] = data["contentType"]
+    if data.get("data") is not None:
+        out["data"] = data["data"]
+    return out

capo_codecatalyst/types/execute_command_session_configuration.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#ExecuteCommandSessionConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.execute_command_session_configuration_arguments
+
+
+class ExecuteCommandSessionConfiguration(TypedDict, closed=True):
+    command: "str"
+    """<p>The command used at the beginning of the SSH session to a Dev Environment.</p>"""
+    arguments: NotRequired[
+        "capo_codecatalyst.types.execute_command_session_configuration_arguments.ExecuteCommandSessionConfigurationArguments"
+    ]
+    """<p>An array of arguments containing arguments and members.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecuteCommandSessionConfiguration) -> dict:
+    out: dict = {}
+    out["command"] = value["command"]
+    if "arguments" in value:
+        import capo_codecatalyst.types.execute_command_session_configuration_arguments
+
+        out["arguments"] = (
+            capo_codecatalyst.types.execute_command_session_configuration_arguments.serialize_json(
+                value["arguments"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ExecuteCommandSessionConfiguration:
+    out: ExecuteCommandSessionConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("command") is not None:
+        out["command"] = data["command"]
+    else:
+        raise DeserializationError(
+            "ExecuteCommandSessionConfiguration.command required"
+        )
+    if data.get("arguments") is not None:
+        import capo_codecatalyst.types.execute_command_session_configuration_arguments
+
+        out["arguments"] = (
+            capo_codecatalyst.types.execute_command_session_configuration_arguments.deserialize_json(
+                data["arguments"]
+            )
+        )
+    return out

capo_codecatalyst/types/execute_command_session_configuration_arguments.py

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

capo_codecatalyst/types/filter.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#Filter``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_codecatalyst.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_codecatalyst.types.string_list
+
+
+class Filter(TypedDict, closed=True):
+    key: "str"
+    """<p>A key that can be used to sort results.</p>"""
+    values: "capo_codecatalyst.types.string_list.StringList"
+    """<p>The values of the key.</p>"""
+    comparison_operator: NotRequired["str"]
+    """<p>The operator used to compare the fields.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Filter) -> dict:
+    out: dict = {}
+    out["key"] = value["key"]
+    import capo_codecatalyst.types.string_list
+
+    out["values"] = capo_codecatalyst.types.string_list.serialize_json(value["values"])
+    if "comparison_operator" in value:
+        out["comparisonOperator"] = value["comparison_operator"]
+    return out
+
+
+def deserialize_json(data: dict) -> Filter:
+    out: Filter = {}  # type: ignore[typeddict-item]
+    if data.get("key") is not None:
+        out["key"] = data["key"]
+    else:
+        raise DeserializationError("Filter.key required")
+    if data.get("values") is not None:
+        import capo_codecatalyst.types.string_list
+
+        out["values"] = capo_codecatalyst.types.string_list.deserialize_json(
+            data["values"]
+        )
+    else:
+        raise DeserializationError("Filter.values required")
+    if data.get("comparisonOperator") is not None:
+        out["comparison_operator"] = data["comparisonOperator"]
+    return out

capo_codecatalyst/types/filter_key.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.codecatalyst#FilterKey``."""
+
+from typing import TypeAlias
+
+FilterKey: TypeAlias = str

capo_codecatalyst/types/filters.py

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