capo-keyspaces 0.1.0__py3-none-any.whl

capo_keyspaces/types/list_keyspaces_response.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListKeyspacesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_summary_list
+    import capo_keyspaces.types.next_token
+
+
+class ListKeyspacesResponse(TypedDict, closed=True):
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p>A token to specify where to start paginating. This is the <code>NextToken</code> from a previously truncated response.</p>"""
+    keyspaces: "capo_keyspaces.types.keyspace_summary_list.KeyspaceSummaryList"
+    """<p>A list of keyspaces.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListKeyspacesResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    import capo_keyspaces.types.keyspace_summary_list
+
+    out["keyspaces"] = (
+        capo_keyspaces.types.keyspace_summary_list.serialize_aws_json_1_0(
+            value["keyspaces"]
+        )
+    )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListKeyspacesResponse:
+    out: ListKeyspacesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("keyspaces") is not None:
+        import capo_keyspaces.types.keyspace_summary_list
+
+        out["keyspaces"] = (
+            capo_keyspaces.types.keyspace_summary_list.deserialize_aws_json_1_0(
+                data["keyspaces"]
+            )
+        )
+    else:
+        raise DeserializationError("ListKeyspacesResponse.keyspaces required")
+    return out

capo_keyspaces/types/list_tables_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListTablesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.max_results
+    import capo_keyspaces.types.next_token
+
+
+class ListTablesRequest(TypedDict, closed=True):
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p>The pagination token. To resume pagination, provide the <code>NextToken</code> value as an argument of a subsequent API invocation.</p>"""
+    max_results: NotRequired["capo_keyspaces.types.max_results.MaxResults"]
+    """<p>The total number of tables to return in the output. If the total number of tables available is more than the value specified, a <code>NextToken</code> is provided in the output. To resume pagination, provide the <code>NextToken</code> value as an argument of a subsequent API invocation.</p>"""
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListTablesRequest) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    out["keyspaceName"] = value["keyspace_name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListTablesRequest:
+    out: ListTablesRequest = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("ListTablesRequest.keyspace_name required")
+    return out

capo_keyspaces/types/list_tables_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListTablesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.next_token
+    import capo_keyspaces.types.table_summary_list
+
+
+class ListTablesResponse(TypedDict, closed=True):
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p>A token to specify where to start paginating. This is the <code>NextToken</code> from a previously truncated response.</p>"""
+    tables: NotRequired["capo_keyspaces.types.table_summary_list.TableSummaryList"]
+    """<p>A list of tables.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListTablesResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "tables" in value:
+        import capo_keyspaces.types.table_summary_list
+
+        out["tables"] = capo_keyspaces.types.table_summary_list.serialize_aws_json_1_0(
+            value["tables"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListTablesResponse:
+    out: ListTablesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("tables") is not None:
+        import capo_keyspaces.types.table_summary_list
+
+        out["tables"] = (
+            capo_keyspaces.types.table_summary_list.deserialize_aws_json_1_0(
+                data["tables"]
+            )
+        )
+    return out

capo_keyspaces/types/list_tags_for_resource_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListTagsForResourceRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.arn
+    import capo_keyspaces.types.max_results
+    import capo_keyspaces.types.next_token
+
+
+class ListTagsForResourceRequest(TypedDict, closed=True):
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The Amazon Resource Name (ARN) of the Amazon Keyspaces resource.</p>"""
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p>The pagination token. To resume pagination, provide the <code>NextToken</code> value as argument of a subsequent API invocation.</p>"""
+    max_results: NotRequired["capo_keyspaces.types.max_results.MaxResults"]
+    """<p>The total number of tags to return in the output. If the total number of tags available is more than the value specified, a <code>NextToken</code> is provided in the output. To resume pagination, provide the <code>NextToken</code> value as an argument of a subsequent API invocation.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListTagsForResourceRequest) -> dict:
+    out: dict = {}
+    out["resourceArn"] = value["resource_arn"]
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListTagsForResourceRequest:
+    out: ListTagsForResourceRequest = {}  # type: ignore[typeddict-item]
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("ListTagsForResourceRequest.resource_arn required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    return out

capo_keyspaces/types/list_tags_for_resource_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListTagsForResourceResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.next_token
+    import capo_keyspaces.types.tag_list
+
+
+class ListTagsForResourceResponse(TypedDict, closed=True):
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p>A token to specify where to start paginating. This is the <code>NextToken</code> from a previously truncated response.</p>"""
+    tags: NotRequired["capo_keyspaces.types.tag_list.TagList"]
+    """<p>A list of tags.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListTagsForResourceResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "tags" in value:
+        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) -> ListTagsForResourceResponse:
+    out: ListTagsForResourceResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    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"]
+        )
+    return out

capo_keyspaces/types/list_types_request.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListTypesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.max_results
+    import capo_keyspaces.types.next_token
+
+
+class ListTypesRequest(TypedDict, closed=True):
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p> The pagination token. To resume pagination, provide the <code>NextToken</code> value as an argument of a subsequent API invocation. </p>"""
+    max_results: NotRequired["capo_keyspaces.types.max_results.MaxResults"]
+    """<p> The total number of types to return in the output. If the total number of types available is more than the value specified, a <code>NextToken</code> is provided in the output. To resume pagination, provide the <code>NextToken</code> value as an argument of a subsequent API invocation. </p>"""
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p> The name of the keyspace that contains the listed types. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListTypesRequest) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    out["keyspaceName"] = value["keyspace_name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListTypesRequest:
+    out: ListTypesRequest = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("ListTypesRequest.keyspace_name required")
+    return out

capo_keyspaces/types/list_types_response.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListTypesResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.next_token
+    import capo_keyspaces.types.type_name_list
+
+
+class ListTypesResponse(TypedDict, closed=True):
+    next_token: NotRequired["capo_keyspaces.types.next_token.NextToken"]
+    """<p> The pagination token. To resume pagination, provide the <code>NextToken</code> value as an argument of a subsequent API invocation. </p>"""
+    types: "capo_keyspaces.types.type_name_list.TypeNameList"
+    """<p> The list of types contained in the specified keyspace. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListTypesResponse) -> dict:
+    out: dict = {}
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    import capo_keyspaces.types.type_name_list
+
+    out["types"] = capo_keyspaces.types.type_name_list.serialize_aws_json_1_0(
+        value["types"]
+    )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListTypesResponse:
+    out: ListTypesResponse = {}  # type: ignore[typeddict-item]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    if data.get("types") is not None:
+        import capo_keyspaces.types.type_name_list
+
+        out["types"] = capo_keyspaces.types.type_name_list.deserialize_aws_json_1_0(
+            data["types"]
+        )
+    else:
+        raise DeserializationError("ListTypesResponse.types required")
+    return out

capo_keyspaces/types/max_results.py

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

capo_keyspaces/types/next_token.py

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

capo_keyspaces/types/partition_key.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#PartitionKey``."""
+
+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 PartitionKey(TypedDict, closed=True):
+    name: "capo_keyspaces.types.generic_string.GenericString"
+    """<p>The name(s) of the partition key column(s).</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: PartitionKey) -> dict:
+    out: dict = {}
+    out["name"] = value["name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> PartitionKey:
+    out: PartitionKey = {}  # type: ignore[typeddict-item]
+    if data.get("name") is not None:
+        out["name"] = data["name"]
+    else:
+        raise DeserializationError("PartitionKey.name required")
+    return out

capo_keyspaces/types/partition_key_list.py

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

capo_keyspaces/types/point_in_time_recovery.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#PointInTimeRecovery``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.point_in_time_recovery_status
+
+
+class PointInTimeRecovery(TypedDict, closed=True):
+    status: (
+        "capo_keyspaces.types.point_in_time_recovery_status.PointInTimeRecoveryStatus"
+    )
+    """<p>The options are:</p> <ul> <li> <p> <code>status=ENABLED</code> </p> </li> <li> <p> <code>status=DISABLED</code> </p> </li> </ul>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: PointInTimeRecovery) -> dict:
+    out: dict = {}
+    out["status"] = value["status"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> PointInTimeRecovery:
+    out: PointInTimeRecovery = {}  # type: ignore[typeddict-item]
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    else:
+        raise DeserializationError("PointInTimeRecovery.status required")
+    return out

capo_keyspaces/types/point_in_time_recovery_status.py

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

capo_keyspaces/types/point_in_time_recovery_summary.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#PointInTimeRecoverySummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.point_in_time_recovery_status
+    import capo_keyspaces.types.timestamp
+
+
+class PointInTimeRecoverySummary(TypedDict, closed=True):
+    status: (
+        "capo_keyspaces.types.point_in_time_recovery_status.PointInTimeRecoveryStatus"
+    )
+    """<p>Shows if point-in-time recovery is enabled or disabled for the specified table.</p>"""
+    earliest_restorable_timestamp: NotRequired[
+        "capo_keyspaces.types.timestamp.Timestamp"
+    ]
+    """<p>Specifies the earliest possible restore point of the table in ISO 8601 format.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: PointInTimeRecoverySummary) -> dict:
+    out: dict = {}
+    out["status"] = value["status"]
+    if "earliest_restorable_timestamp" in value:
+        import capo_keyspaces.types.timestamp
+
+        out["earliestRestorableTimestamp"] = (
+            capo_keyspaces.types.timestamp.serialize_aws_json_1_0(
+                value["earliest_restorable_timestamp"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> PointInTimeRecoverySummary:
+    out: PointInTimeRecoverySummary = {}  # type: ignore[typeddict-item]
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    else:
+        raise DeserializationError("PointInTimeRecoverySummary.status required")
+    if data.get("earliestRestorableTimestamp") is not None:
+        import capo_keyspaces.types.timestamp
+
+        out["earliest_restorable_timestamp"] = (
+            capo_keyspaces.types.timestamp.deserialize_aws_json_1_0(
+                data["earliestRestorableTimestamp"]
+            )
+        )
+    return out

capo_keyspaces/types/region.py

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

capo_keyspaces/types/region_list.py

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

capo_keyspaces/types/replica_auto_scaling_specification.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ReplicaAutoScalingSpecification``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.auto_scaling_specification
+    import capo_keyspaces.types.region
+
+
+class ReplicaAutoScalingSpecification(TypedDict, closed=True):
+    region: NotRequired["capo_keyspaces.types.region.region"]
+    """<p>The Amazon Web Services Region.</p>"""
+    auto_scaling_specification: NotRequired[
+        "capo_keyspaces.types.auto_scaling_specification.AutoScalingSpecification"
+    ]
+    """<p>The auto scaling settings for a multi-Region table in the specified Amazon Web Services Region.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ReplicaAutoScalingSpecification) -> dict:
+    out: dict = {}
+    if "region" in value:
+        out["region"] = value["region"]
+    if "auto_scaling_specification" in value:
+        import capo_keyspaces.types.auto_scaling_specification
+
+        out["autoScalingSpecification"] = (
+            capo_keyspaces.types.auto_scaling_specification.serialize_aws_json_1_0(
+                value["auto_scaling_specification"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ReplicaAutoScalingSpecification:
+    out: ReplicaAutoScalingSpecification = {}  # type: ignore[typeddict-item]
+    if data.get("region") is not None:
+        out["region"] = data["region"]
+    if data.get("autoScalingSpecification") is not None:
+        import capo_keyspaces.types.auto_scaling_specification
+
+        out["auto_scaling_specification"] = (
+            capo_keyspaces.types.auto_scaling_specification.deserialize_aws_json_1_0(
+                data["autoScalingSpecification"]
+            )
+        )
+    return out

capo_keyspaces/types/replica_auto_scaling_specification_list.py

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