capo-keyspaces 0.1.0__py3-none-any.whl

capo_keyspaces/types/schema_definition.py

@@ -0,0 +1,105 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#SchemaDefinition``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.clustering_key_list
+    import capo_keyspaces.types.column_definition_list
+    import capo_keyspaces.types.partition_key_list
+    import capo_keyspaces.types.static_column_list
+
+
+class SchemaDefinition(TypedDict, closed=True):
+    all_columns: "capo_keyspaces.types.column_definition_list.ColumnDefinitionList"
+    """<p>The regular columns of the table.</p>"""
+    partition_keys: "capo_keyspaces.types.partition_key_list.PartitionKeyList"
+    """<p>The columns that are part of the partition key of the table .</p>"""
+    clustering_keys: NotRequired[
+        "capo_keyspaces.types.clustering_key_list.ClusteringKeyList"
+    ]
+    """<p>The columns that are part of the clustering key of the table.</p>"""
+    static_columns: NotRequired[
+        "capo_keyspaces.types.static_column_list.StaticColumnList"
+    ]
+    """<p>The columns that have been defined as <code>STATIC</code>. Static columns store values that are shared by all rows in the same partition.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: SchemaDefinition) -> dict:
+    out: dict = {}
+    import capo_keyspaces.types.column_definition_list
+
+    out["allColumns"] = (
+        capo_keyspaces.types.column_definition_list.serialize_aws_json_1_0(
+            value["all_columns"]
+        )
+    )
+    import capo_keyspaces.types.partition_key_list
+
+    out["partitionKeys"] = (
+        capo_keyspaces.types.partition_key_list.serialize_aws_json_1_0(
+            value["partition_keys"]
+        )
+    )
+    if "clustering_keys" in value:
+        import capo_keyspaces.types.clustering_key_list
+
+        out["clusteringKeys"] = (
+            capo_keyspaces.types.clustering_key_list.serialize_aws_json_1_0(
+                value["clustering_keys"]
+            )
+        )
+    if "static_columns" in value:
+        import capo_keyspaces.types.static_column_list
+
+        out["staticColumns"] = (
+            capo_keyspaces.types.static_column_list.serialize_aws_json_1_0(
+                value["static_columns"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> SchemaDefinition:
+    out: SchemaDefinition = {}  # type: ignore[typeddict-item]
+    if data.get("allColumns") is not None:
+        import capo_keyspaces.types.column_definition_list
+
+        out["all_columns"] = (
+            capo_keyspaces.types.column_definition_list.deserialize_aws_json_1_0(
+                data["allColumns"]
+            )
+        )
+    else:
+        raise DeserializationError("SchemaDefinition.all_columns required")
+    if data.get("partitionKeys") is not None:
+        import capo_keyspaces.types.partition_key_list
+
+        out["partition_keys"] = (
+            capo_keyspaces.types.partition_key_list.deserialize_aws_json_1_0(
+                data["partitionKeys"]
+            )
+        )
+    else:
+        raise DeserializationError("SchemaDefinition.partition_keys required")
+    if data.get("clusteringKeys") is not None:
+        import capo_keyspaces.types.clustering_key_list
+
+        out["clustering_keys"] = (
+            capo_keyspaces.types.clustering_key_list.deserialize_aws_json_1_0(
+                data["clusteringKeys"]
+            )
+        )
+    if data.get("staticColumns") is not None:
+        import capo_keyspaces.types.static_column_list
+
+        out["static_columns"] = (
+            capo_keyspaces.types.static_column_list.deserialize_aws_json_1_0(
+                data["staticColumns"]
+            )
+        )
+    return out

capo_keyspaces/types/sort_order.py

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

capo_keyspaces/types/static_column.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#StaticColumn``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.generic_string
+
+
+class StaticColumn(TypedDict, closed=True):
+    name: "capo_keyspaces.types.generic_string.GenericString"
+    """<p>The name of the static column.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: StaticColumn) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> StaticColumn:
+    out: StaticColumn = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("StaticColumn.name required")
+    return out

capo_keyspaces/types/static_column_list.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#StaticColumnList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.static_column
+
+StaticColumnList: TypeAlias = list["capo_keyspaces.types.static_column.StaticColumn"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: StaticColumnList) -> list:
+    import capo_keyspaces.types.static_column
+
+    out: list = []
+    for item in value:
+        out.append(capo_keyspaces.types.static_column.serialize_aws_json_1_0(item))
+    return out
+
+
+def deserialize_aws_json_1_0(data: list) -> StaticColumnList:
+    import capo_keyspaces.types.static_column
+
+    out: StaticColumnList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_keyspaces.types.static_column.deserialize_aws_json_1_0(item))
+    return out

capo_keyspaces/types/stream_arn.py

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

capo_keyspaces/types/table_name.py

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

capo_keyspaces/types/table_name_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TableNameList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.table_name
+
+TableNameList: TypeAlias = list["capo_keyspaces.types.table_name.TableName"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TableNameList) -> list:
+    return list(value)
+
+
+def deserialize_aws_json_1_0(data: list) -> TableNameList:
+    return [item for item in data if item is not None]

capo_keyspaces/types/table_status.py

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

capo_keyspaces/types/table_summary.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TableSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.table_name
+
+
+class TableSummary(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace that the table is stored in.</p>"""
+    table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the table.</p>"""
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The unique identifier of the table in the format of an Amazon Resource Name (ARN).</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TableSummary) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["tableName"] = value["table_name"]
+    out["resourceArn"] = value["resource_arn"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> TableSummary:
+    out: TableSummary = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("TableSummary.keyspace_name required")
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    else:
+        raise DeserializationError("TableSummary.table_name required")
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("TableSummary.resource_arn required")
+    return out

capo_keyspaces/types/table_summary_list.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TableSummaryList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.table_summary
+
+TableSummaryList: TypeAlias = list["capo_keyspaces.types.table_summary.TableSummary"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TableSummaryList) -> list:
+    import capo_keyspaces.types.table_summary
+
+    out: list = []
+    for item in value:
+        out.append(capo_keyspaces.types.table_summary.serialize_aws_json_1_0(item))
+    return out
+
+
+def deserialize_aws_json_1_0(data: list) -> TableSummaryList:
+    import capo_keyspaces.types.table_summary
+
+    out: TableSummaryList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_keyspaces.types.table_summary.deserialize_aws_json_1_0(item))
+    return out

capo_keyspaces/types/tables_replication_progress.py

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

capo_keyspaces/types/tag.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#Tag``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.tag_key
+    import capo_keyspaces.types.tag_value
+
+
+class Tag(TypedDict, closed=True):
+    key: "capo_keyspaces.types.tag_key.TagKey"
+    """<p>The key of the tag. Tag keys are case sensitive. Each Amazon Keyspaces resource can only have up to one tag with the same key. If you try to add an existing tag (same key), the existing tag value will be updated to the new value.</p>"""
+    value: "capo_keyspaces.types.tag_value.TagValue"
+    """<p>The value of the tag. Tag values are case-sensitive and can be null.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: Tag) -> dict:
+    out: dict = {}
+    out["key"] = value["key"]
+    out["value"] = value["value"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> Tag:
+    out: Tag = {}  # type: ignore[typeddict-item]
+    if data.get("key") is not None:
+        out["key"] = data["key"]
+    else:
+        raise DeserializationError("Tag.key required")
+    if data.get("value") is not None:
+        out["value"] = data["value"]
+    else:
+        raise DeserializationError("Tag.value required")
+    return out

capo_keyspaces/types/tag_key.py

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

capo_keyspaces/types/tag_list.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TagList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.tag
+
+TagList: TypeAlias = list["capo_keyspaces.types.tag.Tag"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TagList) -> list:
+    import capo_keyspaces.types.tag
+
+    out: list = []
+    for item in value:
+        out.append(capo_keyspaces.types.tag.serialize_aws_json_1_0(item))
+    return out
+
+
+def deserialize_aws_json_1_0(data: list) -> TagList:
+    import capo_keyspaces.types.tag
+
+    out: TagList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_keyspaces.types.tag.deserialize_aws_json_1_0(item))
+    return out

capo_keyspaces/types/tag_resource_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+    import capo_keyspaces.types.tag_list
+
+
+class TagResourceRequest(TypedDict, closed=True):
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The Amazon Resource Name (ARN) of the Amazon Keyspaces resource to which to add tags.</p>"""
+    tags: "capo_keyspaces.types.tag_list.TagList"
+    """<p>The tags to be assigned to the Amazon Keyspaces resource.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TagResourceRequest) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    import capo_keyspaces.types.tag_list
+
+    out["tags"] = capo_keyspaces.types.tag_list.serialize_aws_json_1_0(value["tags"])
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> TagResourceRequest:
+    out: TagResourceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("TagResourceRequest.resource_arn required")
+    if data.get("tags") is not None:
+        import capo_keyspaces.types.tag_list
+
+        out["tags"] = capo_keyspaces.types.tag_list.deserialize_aws_json_1_0(
+            data["tags"]
+        )
+    else:
+        raise DeserializationError("TagResourceRequest.tags required")
+    return out

capo_keyspaces/types/tag_resource_response.py

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

capo_keyspaces/types/tag_value.py

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

capo_keyspaces/types/target_tracking_scaling_policy_configuration.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TargetTrackingScalingPolicyConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.boolean_object
+    import capo_keyspaces.types.double_object
+    import capo_keyspaces.types.integer_object
+
+
+class TargetTrackingScalingPolicyConfiguration(TypedDict, closed=True):
+    disable_scale_in: "capo_keyspaces.types.boolean_object.BooleanObject"
+    """<p>Specifies if <code>scale-in</code> is enabled.</p> <p>When auto scaling automatically decreases capacity for a table, the table <i>scales in</i>. When scaling policies are set, they can't scale in the table lower than its minimum capacity.</p>"""
+    scale_in_cooldown: "capo_keyspaces.types.integer_object.IntegerObject"
+    """<p>Specifies a <code>scale-in</code> cool down period.</p> <p>A cooldown period in seconds between scaling activities that lets the table stabilize before another scaling activity starts. </p>"""
+    scale_out_cooldown: "capo_keyspaces.types.integer_object.IntegerObject"
+    """<p>Specifies a scale out cool down period.</p> <p>A cooldown period in seconds between scaling activities that lets the table stabilize before another scaling activity starts. </p>"""
+    target_value: "capo_keyspaces.types.double_object.DoubleObject"
+    """<p>Specifies the target value for the target tracking auto scaling policy.</p> <p>Amazon Keyspaces auto scaling scales up capacity automatically when traffic exceeds this target utilization rate, and then back down when it falls below the target. This ensures that the ratio of consumed capacity to provisioned capacity stays at or near this value. You define <code>targetValue</code> as a percentage. A <code>double</code> between 20 and 90.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TargetTrackingScalingPolicyConfiguration) -> dict:
+    out: dict = {}
+    out["disableScaleIn"] = value.get("disable_scale_in", False)
+    out["scaleInCooldown"] = value.get("scale_in_cooldown", 0)
+    out["scaleOutCooldown"] = value.get("scale_out_cooldown", 0)
+    out["targetValue"] = (
+        "NaN"
+        if value.get("target_value", 0) != value.get("target_value", 0)
+        else "Infinity"
+        if value.get("target_value", 0) == float("inf")
+        else "-Infinity"
+        if value.get("target_value", 0) == float("-inf")
+        else value.get("target_value", 0)
+    )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> TargetTrackingScalingPolicyConfiguration:
+    out: TargetTrackingScalingPolicyConfiguration = {}  # type: ignore[typeddict-item]
+    if data.get("disableScaleIn") is not None:
+        out["disable_scale_in"] = data["disableScaleIn"]
+    else:
+        out["disable_scale_in"] = False
+    if data.get("scaleInCooldown") is not None:
+        out["scale_in_cooldown"] = data["scaleInCooldown"]
+    else:
+        out["scale_in_cooldown"] = 0
+    if data.get("scaleOutCooldown") is not None:
+        out["scale_out_cooldown"] = data["scaleOutCooldown"]
+    else:
+        out["scale_out_cooldown"] = 0
+    if data.get("targetValue") is not None:
+        out["target_value"] = float(data["targetValue"])
+    else:
+        out["target_value"] = 0
+    return out

capo_keyspaces/types/throughput_mode.py

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

capo_keyspaces/types/time_to_live.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TimeToLive``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.time_to_live_status
+
+
+class TimeToLive(TypedDict, closed=True):
+    status: "capo_keyspaces.types.time_to_live_status.TimeToLiveStatus"
+    """<p>Shows how to enable custom Time to Live (TTL) settings for the specified table.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TimeToLive) -> dict:
+    out: dict = {}
+    out["status"] = value["status"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> TimeToLive:
+    out: TimeToLive = {}  # type: ignore[typeddict-item]
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    else:
+        raise DeserializationError("TimeToLive.status required")
+    return out

capo_keyspaces/types/time_to_live_status.py

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

capo_keyspaces/types/timestamp.py

@@ -0,0 +1,20 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#Timestamp``."""
+
+import datetime
+from typing import TypeAlias
+
+Timestamp: TypeAlias = datetime.datetime
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: Timestamp) -> float:
+    value = (
+        value.astimezone(datetime.timezone.utc)
+        if value.tzinfo
+        else value.replace(tzinfo=datetime.timezone.utc)
+    )
+    return value.timestamp()
+
+
+def deserialize_aws_json_1_0(data: float) -> Timestamp:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

capo_keyspaces/types/type_name.py

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

capo_keyspaces/types/type_name_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#TypeNameList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.type_name
+
+TypeNameList: TypeAlias = list["capo_keyspaces.types.type_name.TypeName"]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: TypeNameList) -> list:
+    return list(value)
+
+
+def deserialize_aws_json_1_0(data: list) -> TypeNameList:
+    return [item for item in data if item is not None]

capo_keyspaces/types/type_status.py

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

capo_keyspaces/types/untag_resource_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#UntagResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+    import capo_keyspaces.types.tag_list
+
+
+class UntagResourceRequest(TypedDict, closed=True):
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The Amazon Keyspaces resource that the tags will be removed from. This value is an Amazon Resource Name (ARN).</p>"""
+    tags: "capo_keyspaces.types.tag_list.TagList"
+    """<p>A list of existing tags to be removed from the Amazon Keyspaces resource.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: UntagResourceRequest) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    import capo_keyspaces.types.tag_list
+
+    out["tags"] = capo_keyspaces.types.tag_list.serialize_aws_json_1_0(value["tags"])
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> UntagResourceRequest:
+    out: UntagResourceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("UntagResourceRequest.resource_arn required")
+    if data.get("tags") is not None:
+        import capo_keyspaces.types.tag_list
+
+        out["tags"] = capo_keyspaces.types.tag_list.deserialize_aws_json_1_0(
+            data["tags"]
+        )
+    else:
+        raise DeserializationError("UntagResourceRequest.tags required")
+    return out