capo-keyspaces 0.1.0__py3-none-any.whl

capo_keyspaces/types/get_table_response.py

@@ -0,0 +1,287 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetTableResponse``."""
+
+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.capacity_specification_summary
+    import capo_keyspaces.types.cdc_specification_summary
+    import capo_keyspaces.types.client_side_timestamps
+    import capo_keyspaces.types.comment
+    import capo_keyspaces.types.default_time_to_live
+    import capo_keyspaces.types.encryption_specification
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.point_in_time_recovery_summary
+    import capo_keyspaces.types.replica_specification_summary_list
+    import capo_keyspaces.types.schema_definition
+    import capo_keyspaces.types.stream_arn
+    import capo_keyspaces.types.table_name
+    import capo_keyspaces.types.table_status
+    import capo_keyspaces.types.time_to_live
+    import capo_keyspaces.types.timestamp
+    import capo_keyspaces.types.warm_throughput_specification_summary
+
+
+class GetTableResponse(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace that the specified table is stored in.</p>"""
+    table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the specified table.</p>"""
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The Amazon Resource Name (ARN) of the specified table.</p>"""
+    creation_timestamp: NotRequired["capo_keyspaces.types.timestamp.Timestamp"]
+    """<p>The creation timestamp of the specified table.</p>"""
+    status: NotRequired["capo_keyspaces.types.table_status.TableStatus"]
+    """<p>The current status of the specified table.</p>"""
+    schema_definition: NotRequired[
+        "capo_keyspaces.types.schema_definition.SchemaDefinition"
+    ]
+    """<p>The schema definition of the specified table.</p>"""
+    capacity_specification: NotRequired[
+        "capo_keyspaces.types.capacity_specification_summary.CapacitySpecificationSummary"
+    ]
+    """<p>The read/write throughput capacity mode for a table. The options are:</p> <ul> <li> <p> <code>throughputMode:PAY_PER_REQUEST</code> </p> </li> <li> <p> <code>throughputMode:PROVISIONED</code> </p> </li> </ul>"""
+    encryption_specification: NotRequired[
+        "capo_keyspaces.types.encryption_specification.EncryptionSpecification"
+    ]
+    """<p>The encryption settings of the specified table.</p>"""
+    point_in_time_recovery: NotRequired[
+        "capo_keyspaces.types.point_in_time_recovery_summary.PointInTimeRecoverySummary"
+    ]
+    """<p>The point-in-time recovery status of the specified table.</p>"""
+    ttl: NotRequired["capo_keyspaces.types.time_to_live.TimeToLive"]
+    """<p>The custom Time to Live settings of the specified table.</p>"""
+    default_time_to_live: NotRequired[
+        "capo_keyspaces.types.default_time_to_live.DefaultTimeToLive"
+    ]
+    """<p>The default Time to Live settings in seconds of the specified table.</p>"""
+    comment: NotRequired["capo_keyspaces.types.comment.Comment"]
+    """<p>The the description of the specified table.</p>"""
+    client_side_timestamps: NotRequired[
+        "capo_keyspaces.types.client_side_timestamps.ClientSideTimestamps"
+    ]
+    """<p> The client-side timestamps setting of the table.</p>"""
+    replica_specifications: NotRequired[
+        "capo_keyspaces.types.replica_specification_summary_list.ReplicaSpecificationSummaryList"
+    ]
+    """<p>Returns the Amazon Web Services Region specific settings of all Regions a multi-Region table is replicated in.</p>"""
+    latest_stream_arn: NotRequired["capo_keyspaces.types.stream_arn.StreamArn"]
+    """<p>The Amazon Resource Name (ARN) of the stream.</p>"""
+    cdc_specification: NotRequired[
+        "capo_keyspaces.types.cdc_specification_summary.CdcSpecificationSummary"
+    ]
+    """<p>The CDC stream settings of the table.</p>"""
+    warm_throughput_specification: NotRequired[
+        "capo_keyspaces.types.warm_throughput_specification_summary.WarmThroughputSpecificationSummary"
+    ]
+    """<p>The warm throughput settings for the table, including the current status and configured read and write capacity units.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetTableResponse) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["tableName"] = value["table_name"]
+    out["resourceArn"] = value["resource_arn"]
+    if "creation_timestamp" in value:
+        import capo_keyspaces.types.timestamp
+
+        out["creationTimestamp"] = (
+            capo_keyspaces.types.timestamp.serialize_aws_json_1_0(
+                value["creation_timestamp"]
+            )
+        )
+    if "status" in value:
+        out["status"] = value["status"]
+    if "schema_definition" in value:
+        import capo_keyspaces.types.schema_definition
+
+        out["schemaDefinition"] = (
+            capo_keyspaces.types.schema_definition.serialize_aws_json_1_0(
+                value["schema_definition"]
+            )
+        )
+    if "capacity_specification" in value:
+        import capo_keyspaces.types.capacity_specification_summary
+
+        out["capacitySpecification"] = (
+            capo_keyspaces.types.capacity_specification_summary.serialize_aws_json_1_0(
+                value["capacity_specification"]
+            )
+        )
+    if "encryption_specification" in value:
+        import capo_keyspaces.types.encryption_specification
+
+        out["encryptionSpecification"] = (
+            capo_keyspaces.types.encryption_specification.serialize_aws_json_1_0(
+                value["encryption_specification"]
+            )
+        )
+    if "point_in_time_recovery" in value:
+        import capo_keyspaces.types.point_in_time_recovery_summary
+
+        out["pointInTimeRecovery"] = (
+            capo_keyspaces.types.point_in_time_recovery_summary.serialize_aws_json_1_0(
+                value["point_in_time_recovery"]
+            )
+        )
+    if "ttl" in value:
+        import capo_keyspaces.types.time_to_live
+
+        out["ttl"] = capo_keyspaces.types.time_to_live.serialize_aws_json_1_0(
+            value["ttl"]
+        )
+    if "default_time_to_live" in value:
+        out["defaultTimeToLive"] = value["default_time_to_live"]
+    if "comment" in value:
+        import capo_keyspaces.types.comment
+
+        out["comment"] = capo_keyspaces.types.comment.serialize_aws_json_1_0(
+            value["comment"]
+        )
+    if "client_side_timestamps" in value:
+        import capo_keyspaces.types.client_side_timestamps
+
+        out["clientSideTimestamps"] = (
+            capo_keyspaces.types.client_side_timestamps.serialize_aws_json_1_0(
+                value["client_side_timestamps"]
+            )
+        )
+    if "replica_specifications" in value:
+        import capo_keyspaces.types.replica_specification_summary_list
+
+        out["replicaSpecifications"] = (
+            capo_keyspaces.types.replica_specification_summary_list.serialize_aws_json_1_0(
+                value["replica_specifications"]
+            )
+        )
+    if "latest_stream_arn" in value:
+        out["latestStreamArn"] = value["latest_stream_arn"]
+    if "cdc_specification" in value:
+        import capo_keyspaces.types.cdc_specification_summary
+
+        out["cdcSpecification"] = (
+            capo_keyspaces.types.cdc_specification_summary.serialize_aws_json_1_0(
+                value["cdc_specification"]
+            )
+        )
+    if "warm_throughput_specification" in value:
+        import capo_keyspaces.types.warm_throughput_specification_summary
+
+        out["warmThroughputSpecification"] = (
+            capo_keyspaces.types.warm_throughput_specification_summary.serialize_aws_json_1_0(
+                value["warm_throughput_specification"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetTableResponse:
+    out: GetTableResponse = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("GetTableResponse.keyspace_name required")
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    else:
+        raise DeserializationError("GetTableResponse.table_name required")
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("GetTableResponse.resource_arn required")
+    if data.get("creationTimestamp") is not None:
+        import capo_keyspaces.types.timestamp
+
+        out["creation_timestamp"] = (
+            capo_keyspaces.types.timestamp.deserialize_aws_json_1_0(
+                data["creationTimestamp"]
+            )
+        )
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    if data.get("schemaDefinition") is not None:
+        import capo_keyspaces.types.schema_definition
+
+        out["schema_definition"] = (
+            capo_keyspaces.types.schema_definition.deserialize_aws_json_1_0(
+                data["schemaDefinition"]
+            )
+        )
+    if data.get("capacitySpecification") is not None:
+        import capo_keyspaces.types.capacity_specification_summary
+
+        out["capacity_specification"] = (
+            capo_keyspaces.types.capacity_specification_summary.deserialize_aws_json_1_0(
+                data["capacitySpecification"]
+            )
+        )
+    if data.get("encryptionSpecification") is not None:
+        import capo_keyspaces.types.encryption_specification
+
+        out["encryption_specification"] = (
+            capo_keyspaces.types.encryption_specification.deserialize_aws_json_1_0(
+                data["encryptionSpecification"]
+            )
+        )
+    if data.get("pointInTimeRecovery") is not None:
+        import capo_keyspaces.types.point_in_time_recovery_summary
+
+        out["point_in_time_recovery"] = (
+            capo_keyspaces.types.point_in_time_recovery_summary.deserialize_aws_json_1_0(
+                data["pointInTimeRecovery"]
+            )
+        )
+    if data.get("ttl") is not None:
+        import capo_keyspaces.types.time_to_live
+
+        out["ttl"] = capo_keyspaces.types.time_to_live.deserialize_aws_json_1_0(
+            data["ttl"]
+        )
+    if data.get("defaultTimeToLive") is not None:
+        out["default_time_to_live"] = data["defaultTimeToLive"]
+    if data.get("comment") is not None:
+        import capo_keyspaces.types.comment
+
+        out["comment"] = capo_keyspaces.types.comment.deserialize_aws_json_1_0(
+            data["comment"]
+        )
+    if data.get("clientSideTimestamps") is not None:
+        import capo_keyspaces.types.client_side_timestamps
+
+        out["client_side_timestamps"] = (
+            capo_keyspaces.types.client_side_timestamps.deserialize_aws_json_1_0(
+                data["clientSideTimestamps"]
+            )
+        )
+    if data.get("replicaSpecifications") is not None:
+        import capo_keyspaces.types.replica_specification_summary_list
+
+        out["replica_specifications"] = (
+            capo_keyspaces.types.replica_specification_summary_list.deserialize_aws_json_1_0(
+                data["replicaSpecifications"]
+            )
+        )
+    if data.get("latestStreamArn") is not None:
+        out["latest_stream_arn"] = data["latestStreamArn"]
+    if data.get("cdcSpecification") is not None:
+        import capo_keyspaces.types.cdc_specification_summary
+
+        out["cdc_specification"] = (
+            capo_keyspaces.types.cdc_specification_summary.deserialize_aws_json_1_0(
+                data["cdcSpecification"]
+            )
+        )
+    if data.get("warmThroughputSpecification") is not None:
+        import capo_keyspaces.types.warm_throughput_specification_summary
+
+        out["warm_throughput_specification"] = (
+            capo_keyspaces.types.warm_throughput_specification_summary.deserialize_aws_json_1_0(
+                data["warmThroughputSpecification"]
+            )
+        )
+    return out

capo_keyspaces/types/get_type_request.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetTypeRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.type_name
+
+
+class GetTypeRequest(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p> The name of the keyspace that contains this type. </p>"""
+    type_name: "capo_keyspaces.types.type_name.TypeName"
+    """<p>The formatted name of the type. For example, if the name of the type was created without double quotes, Amazon Keyspaces saved the name in lower-case characters. If the name was created in double quotes, you must use double quotes to specify the type name. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetTypeRequest) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["typeName"] = value["type_name"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetTypeRequest:
+    out: GetTypeRequest = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("GetTypeRequest.keyspace_name required")
+    if data.get("typeName") is not None:
+        out["type_name"] = data["typeName"]
+    else:
+        raise DeserializationError("GetTypeRequest.type_name required")
+    return out

capo_keyspaces/types/get_type_response.py

@@ -0,0 +1,140 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#GetTypeResponse``."""
+
+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.depth
+    import capo_keyspaces.types.field_list
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.table_name_list
+    import capo_keyspaces.types.timestamp
+    import capo_keyspaces.types.type_name
+    import capo_keyspaces.types.type_name_list
+    import capo_keyspaces.types.type_status
+
+
+class GetTypeResponse(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p> The name of the keyspace that contains this type. </p>"""
+    type_name: "capo_keyspaces.types.type_name.TypeName"
+    """<p> The name of the type. </p>"""
+    field_definitions: NotRequired["capo_keyspaces.types.field_list.FieldList"]
+    """<p> The names and types that define this type. </p>"""
+    last_modified_timestamp: NotRequired["capo_keyspaces.types.timestamp.Timestamp"]
+    """<p> The timestamp that shows when this type was last modified. </p>"""
+    status: NotRequired["capo_keyspaces.types.type_status.TypeStatus"]
+    """<p> The status of this type. </p>"""
+    direct_referring_tables: NotRequired[
+        "capo_keyspaces.types.table_name_list.TableNameList"
+    ]
+    """<p> The tables that use this type. </p>"""
+    direct_parent_types: NotRequired["capo_keyspaces.types.type_name_list.TypeNameList"]
+    """<p> The types that use this type. </p>"""
+    max_nesting_depth: "capo_keyspaces.types.depth.Depth"
+    """<p> The level of nesting implemented for this type. </p>"""
+    keyspace_arn: "capo_keyspaces.types.arn.ARN"
+    """<p> The unique identifier of the keyspace that contains this type in the format of an Amazon Resource Name (ARN). </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: GetTypeResponse) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["typeName"] = value["type_name"]
+    if "field_definitions" in value:
+        import capo_keyspaces.types.field_list
+
+        out["fieldDefinitions"] = (
+            capo_keyspaces.types.field_list.serialize_aws_json_1_0(
+                value["field_definitions"]
+            )
+        )
+    if "last_modified_timestamp" in value:
+        import capo_keyspaces.types.timestamp
+
+        out["lastModifiedTimestamp"] = (
+            capo_keyspaces.types.timestamp.serialize_aws_json_1_0(
+                value["last_modified_timestamp"]
+            )
+        )
+    if "status" in value:
+        out["status"] = value["status"]
+    if "direct_referring_tables" in value:
+        import capo_keyspaces.types.table_name_list
+
+        out["directReferringTables"] = (
+            capo_keyspaces.types.table_name_list.serialize_aws_json_1_0(
+                value["direct_referring_tables"]
+            )
+        )
+    if "direct_parent_types" in value:
+        import capo_keyspaces.types.type_name_list
+
+        out["directParentTypes"] = (
+            capo_keyspaces.types.type_name_list.serialize_aws_json_1_0(
+                value["direct_parent_types"]
+            )
+        )
+    out["maxNestingDepth"] = value.get("max_nesting_depth", 0)
+    out["keyspaceArn"] = value["keyspace_arn"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> GetTypeResponse:
+    out: GetTypeResponse = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("GetTypeResponse.keyspace_name required")
+    if data.get("typeName") is not None:
+        out["type_name"] = data["typeName"]
+    else:
+        raise DeserializationError("GetTypeResponse.type_name required")
+    if data.get("fieldDefinitions") is not None:
+        import capo_keyspaces.types.field_list
+
+        out["field_definitions"] = (
+            capo_keyspaces.types.field_list.deserialize_aws_json_1_0(
+                data["fieldDefinitions"]
+            )
+        )
+    if data.get("lastModifiedTimestamp") is not None:
+        import capo_keyspaces.types.timestamp
+
+        out["last_modified_timestamp"] = (
+            capo_keyspaces.types.timestamp.deserialize_aws_json_1_0(
+                data["lastModifiedTimestamp"]
+            )
+        )
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    if data.get("directReferringTables") is not None:
+        import capo_keyspaces.types.table_name_list
+
+        out["direct_referring_tables"] = (
+            capo_keyspaces.types.table_name_list.deserialize_aws_json_1_0(
+                data["directReferringTables"]
+            )
+        )
+    if data.get("directParentTypes") is not None:
+        import capo_keyspaces.types.type_name_list
+
+        out["direct_parent_types"] = (
+            capo_keyspaces.types.type_name_list.deserialize_aws_json_1_0(
+                data["directParentTypes"]
+            )
+        )
+    if data.get("maxNestingDepth") is not None:
+        out["max_nesting_depth"] = data["maxNestingDepth"]
+    else:
+        out["max_nesting_depth"] = 0
+    if data.get("keyspaceArn") is not None:
+        out["keyspace_arn"] = data["keyspaceArn"]
+    else:
+        raise DeserializationError("GetTypeResponse.keyspace_arn required")
+    return out

capo_keyspaces/types/integer_object.py

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

capo_keyspaces/types/keyspace_name.py

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

capo_keyspaces/types/keyspace_status.py

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

capo_keyspaces/types/keyspace_summary.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#KeyspaceSummary``."""
+
+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.keyspace_name
+    import capo_keyspaces.types.region_list
+    import capo_keyspaces.types.rs
+
+
+class KeyspaceSummary(TypedDict, closed=True):
+    keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the keyspace.</p>"""
+    resource_arn: "capo_keyspaces.types.arn.ARN"
+    """<p>The unique identifier of the keyspace in the format of an Amazon Resource Name (ARN).</p>"""
+    replication_strategy: "capo_keyspaces.types.rs.rs"
+    """<p> This property specifies if a keyspace is a single Region keyspace or a multi-Region keyspace. The available values are <code>SINGLE_REGION</code> or <code>MULTI_REGION</code>. </p>"""
+    replication_regions: NotRequired["capo_keyspaces.types.region_list.RegionList"]
+    """<p> If the <code>replicationStrategy</code> of the keyspace is <code>MULTI_REGION</code>, a list of replication Regions is returned. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: KeyspaceSummary) -> dict:
+    out: dict = {}
+    out["keyspaceName"] = value["keyspace_name"]
+    out["resourceArn"] = value["resource_arn"]
+    out["replicationStrategy"] = value["replication_strategy"]
+    if "replication_regions" in value:
+        import capo_keyspaces.types.region_list
+
+        out["replicationRegions"] = (
+            capo_keyspaces.types.region_list.serialize_aws_json_1_0(
+                value["replication_regions"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspaceSummary:
+    out: KeyspaceSummary = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    else:
+        raise DeserializationError("KeyspaceSummary.keyspace_name required")
+    if data.get("resourceArn") is not None:
+        out["resource_arn"] = data["resourceArn"]
+    else:
+        raise DeserializationError("KeyspaceSummary.resource_arn required")
+    if data.get("replicationStrategy") is not None:
+        out["replication_strategy"] = data["replicationStrategy"]
+    else:
+        raise DeserializationError("KeyspaceSummary.replication_strategy required")
+    if data.get("replicationRegions") is not None:
+        import capo_keyspaces.types.region_list
+
+        out["replication_regions"] = (
+            capo_keyspaces.types.region_list.deserialize_aws_json_1_0(
+                data["replicationRegions"]
+            )
+        )
+    return out

capo_keyspaces/types/keyspace_summary_list.py

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

capo_keyspaces/types/kms_key_arn.py

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

capo_keyspaces/types/list_keyspaces_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ListKeyspacesRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.max_results
+    import capo_keyspaces.types.next_token
+
+
+class ListKeyspacesRequest(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 argument of a subsequent API invocation.</p>"""
+    max_results: NotRequired["capo_keyspaces.types.max_results.MaxResults"]
+    """<p>The total number of keyspaces to return in the output. If the total number of keyspaces 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: ListKeyspacesRequest) -> dict:
+    out: dict = {}
+    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) -> ListKeyspacesRequest:
+    out: ListKeyspacesRequest = {}  # 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"]
+    return out