capo-keyspaces 0.1.0__py3-none-any.whl

capo_keyspaces/types/replica_specification.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ReplicaSpecification``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.auto_scaling_settings
+    import capo_keyspaces.types.capacity_units
+    import capo_keyspaces.types.region
+
+
+class ReplicaSpecification(TypedDict, closed=True):
+    region: "capo_keyspaces.types.region.region"
+    """<p>The Amazon Web Services Region.</p>"""
+    read_capacity_units: NotRequired[
+        "capo_keyspaces.types.capacity_units.CapacityUnits"
+    ]
+    """<p>The provisioned read capacity units for the multi-Region table in the specified Amazon Web Services Region.</p>"""
+    read_capacity_auto_scaling: NotRequired[
+        "capo_keyspaces.types.auto_scaling_settings.AutoScalingSettings"
+    ]
+    """<p>The read capacity auto scaling settings for the multi-Region table in the specified Amazon Web Services Region.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ReplicaSpecification) -> dict:
+    out: dict = {}
+    out["region"] = value["region"]
+    if "read_capacity_units" in value:
+        out["readCapacityUnits"] = value["read_capacity_units"]
+    if "read_capacity_auto_scaling" in value:
+        import capo_keyspaces.types.auto_scaling_settings
+
+        out["readCapacityAutoScaling"] = (
+            capo_keyspaces.types.auto_scaling_settings.serialize_aws_json_1_0(
+                value["read_capacity_auto_scaling"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ReplicaSpecification:
+    out: ReplicaSpecification = {}  # type: ignore[typeddict-item]
+    if data.get("region") is not None:
+        out["region"] = data["region"]
+    else:
+        raise DeserializationError("ReplicaSpecification.region required")
+    if data.get("readCapacityUnits") is not None:
+        out["read_capacity_units"] = data["readCapacityUnits"]
+    if data.get("readCapacityAutoScaling") is not None:
+        import capo_keyspaces.types.auto_scaling_settings
+
+        out["read_capacity_auto_scaling"] = (
+            capo_keyspaces.types.auto_scaling_settings.deserialize_aws_json_1_0(
+                data["readCapacityAutoScaling"]
+            )
+        )
+    return out

capo_keyspaces/types/replica_specification_list.py

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

capo_keyspaces/types/replica_specification_summary.py

@@ -0,0 +1,76 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ReplicaSpecificationSummary``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.capacity_specification_summary
+    import capo_keyspaces.types.region
+    import capo_keyspaces.types.table_status
+    import capo_keyspaces.types.warm_throughput_specification_summary
+
+
+class ReplicaSpecificationSummary(TypedDict, closed=True):
+    region: NotRequired["capo_keyspaces.types.region.region"]
+    """<p>The Amazon Web Services Region.</p>"""
+    status: NotRequired["capo_keyspaces.types.table_status.TableStatus"]
+    """<p>The status of the multi-Region table in the specified Amazon Web Services Region.</p>"""
+    capacity_specification: NotRequired[
+        "capo_keyspaces.types.capacity_specification_summary.CapacitySpecificationSummary"
+    ]
+    warm_throughput_specification: NotRequired[
+        "capo_keyspaces.types.warm_throughput_specification_summary.WarmThroughputSpecificationSummary"
+    ]
+    """<p>The warm throughput settings for this replica, including the current status and configured read and write capacity units.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ReplicaSpecificationSummary) -> dict:
+    out: dict = {}
+    if "region" in value:
+        out["region"] = value["region"]
+    if "status" in value:
+        out["status"] = value["status"]
+    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 "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) -> ReplicaSpecificationSummary:
+    out: ReplicaSpecificationSummary = {}  # type: ignore[typeddict-item]
+    if data.get("region") is not None:
+        out["region"] = data["region"]
+    if data.get("status") is not None:
+        out["status"] = data["status"]
+    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("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/replica_specification_summary_list.py

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

capo_keyspaces/types/replication_group_status.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ReplicationGroupStatus``."""
+
+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_status
+    import capo_keyspaces.types.region
+    import capo_keyspaces.types.tables_replication_progress
+
+
+class ReplicationGroupStatus(TypedDict, closed=True):
+    region: "capo_keyspaces.types.region.region"
+    """<p> The name of the Region that was added to the keyspace. </p>"""
+    keyspace_status: "capo_keyspaces.types.keyspace_status.KeyspaceStatus"
+    """<p> The status of the keyspace. </p>"""
+    tables_replication_progress: NotRequired[
+        "capo_keyspaces.types.tables_replication_progress.TablesReplicationProgress"
+    ]
+    """<p> This shows the replication progress of tables in the keyspace. The value is expressed as a percentage of the newly replicated tables with status <code>Active</code> compared to the total number of tables in the keyspace. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ReplicationGroupStatus) -> dict:
+    out: dict = {}
+    out["region"] = value["region"]
+    out["keyspaceStatus"] = value["keyspace_status"]
+    if "tables_replication_progress" in value:
+        out["tablesReplicationProgress"] = value["tables_replication_progress"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ReplicationGroupStatus:
+    out: ReplicationGroupStatus = {}  # type: ignore[typeddict-item]
+    if data.get("region") is not None:
+        out["region"] = data["region"]
+    else:
+        raise DeserializationError("ReplicationGroupStatus.region required")
+    if data.get("keyspaceStatus") is not None:
+        out["keyspace_status"] = data["keyspaceStatus"]
+    else:
+        raise DeserializationError("ReplicationGroupStatus.keyspace_status required")
+    if data.get("tablesReplicationProgress") is not None:
+        out["tables_replication_progress"] = data["tablesReplicationProgress"]
+    return out

capo_keyspaces/types/replication_group_status_list.py

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

capo_keyspaces/types/replication_specification.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#ReplicationSpecification``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.region_list
+    import capo_keyspaces.types.rs
+
+
+class ReplicationSpecification(TypedDict, closed=True):
+    replication_strategy: "capo_keyspaces.types.rs.rs"
+    """<p> The <code>replicationStrategy</code> of a keyspace, the required value is <code>SINGLE_REGION</code> or <code>MULTI_REGION</code>. </p>"""
+    region_list: NotRequired["capo_keyspaces.types.region_list.RegionList"]
+    """<p> The <code>regionList</code> contains the Amazon Web Services Regions where the keyspace is replicated in. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ReplicationSpecification) -> dict:
+    out: dict = {}
+    out["replicationStrategy"] = value["replication_strategy"]
+    if "region_list" in value:
+        import capo_keyspaces.types.region_list
+
+        out["regionList"] = capo_keyspaces.types.region_list.serialize_aws_json_1_0(
+            value["region_list"]
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ReplicationSpecification:
+    out: ReplicationSpecification = {}  # type: ignore[typeddict-item]
+    if data.get("replicationStrategy") is not None:
+        out["replication_strategy"] = data["replicationStrategy"]
+    else:
+        raise DeserializationError(
+            "ReplicationSpecification.replication_strategy required"
+        )
+    if data.get("regionList") is not None:
+        import capo_keyspaces.types.region_list
+
+        out["region_list"] = capo_keyspaces.types.region_list.deserialize_aws_json_1_0(
+            data["regionList"]
+        )
+    return out

capo_keyspaces/types/restore_table_request.py

@@ -0,0 +1,190 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspaces#RestoreTableRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_keyspaces.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_keyspaces.types.auto_scaling_specification
+    import capo_keyspaces.types.capacity_specification
+    import capo_keyspaces.types.encryption_specification
+    import capo_keyspaces.types.keyspace_name
+    import capo_keyspaces.types.point_in_time_recovery
+    import capo_keyspaces.types.replica_specification_list
+    import capo_keyspaces.types.table_name
+    import capo_keyspaces.types.tag_list
+    import capo_keyspaces.types.timestamp
+
+
+class RestoreTableRequest(TypedDict, closed=True):
+    source_keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The keyspace name of the source table.</p>"""
+    source_table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the source table.</p>"""
+    target_keyspace_name: "capo_keyspaces.types.keyspace_name.KeyspaceName"
+    """<p>The name of the target keyspace.</p>"""
+    target_table_name: "capo_keyspaces.types.table_name.TableName"
+    """<p>The name of the target table.</p>"""
+    restore_timestamp: NotRequired["capo_keyspaces.types.timestamp.Timestamp"]
+    """<p>The restore timestamp in ISO 8601 format.</p>"""
+    capacity_specification_override: NotRequired[
+        "capo_keyspaces.types.capacity_specification.CapacitySpecification"
+    ]
+    r"""<p>Specifies the read/write throughput capacity mode for the target table. The options are:</p> <ul> <li> <p> <code>throughputMode:PAY_PER_REQUEST</code> </p> </li> <li> <p> <code>throughputMode:PROVISIONED</code> - Provisioned capacity mode requires <code>readCapacityUnits</code> and <code>writeCapacityUnits</code> as input.</p> </li> </ul> <p>The default is <code>throughput_mode:PAY_PER_REQUEST</code>.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/ReadWriteCapacityMode.html\">Read/write capacity modes</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+    encryption_specification_override: NotRequired[
+        "capo_keyspaces.types.encryption_specification.EncryptionSpecification"
+    ]
+    r"""<p>Specifies the encryption settings for the target table. You can choose one of the following KMS key (KMS key):</p> <ul> <li> <p> <code>type:AWS_OWNED_KMS_KEY</code> - This key is owned by Amazon Keyspaces. </p> </li> <li> <p> <code>type:CUSTOMER_MANAGED_KMS_KEY</code> - This key is stored in your account and is created, owned, and managed by you. This option requires the <code>kms_key_identifier</code> of the KMS key in Amazon Resource Name (ARN) format as input. </p> </li> </ul> <p>The default is <code>type:AWS_OWNED_KMS_KEY</code>.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/EncryptionAtRest.html\">Encryption at rest</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+    point_in_time_recovery_override: NotRequired[
+        "capo_keyspaces.types.point_in_time_recovery.PointInTimeRecovery"
+    ]
+    r"""<p>Specifies the <code>pointInTimeRecovery</code> settings for the target table. The options are:</p> <ul> <li> <p> <code>status=ENABLED</code> </p> </li> <li> <p> <code>status=DISABLED</code> </p> </li> </ul> <p>If it's not specified, the default is <code>status=DISABLED</code>.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/PointInTimeRecovery.html\">Point-in-time recovery</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+    tags_override: NotRequired["capo_keyspaces.types.tag_list.TagList"]
+    r"""<p>A list of key-value pair tags to be attached to the restored table. </p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/tagging-keyspaces.html\">Adding tags and labels to Amazon Keyspaces resources</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+    auto_scaling_specification: NotRequired[
+        "capo_keyspaces.types.auto_scaling_specification.AutoScalingSpecification"
+    ]
+    r"""<p>The optional auto scaling settings for the restored table in provisioned capacity mode. Specifies if the service can manage throughput capacity of a provisioned table automatically on your behalf. Amazon Keyspaces auto scaling helps you provision throughput capacity for variable workloads efficiently by increasing and decreasing your table's read and write capacity automatically in response to application traffic.</p> <p>For more information, see <a href=\"https://docs.aws.amazon.com/keyspaces/latest/devguide/autoscaling.html\">Managing throughput capacity automatically with Amazon Keyspaces auto scaling</a> in the <i>Amazon Keyspaces Developer Guide</i>.</p>"""
+    replica_specifications: NotRequired[
+        "capo_keyspaces.types.replica_specification_list.ReplicaSpecificationList"
+    ]
+    """<p>The optional Region specific settings of a multi-Regional table.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: RestoreTableRequest) -> dict:
+    out: dict = {}
+    out["sourceKeyspaceName"] = value["source_keyspace_name"]
+    out["sourceTableName"] = value["source_table_name"]
+    out["targetKeyspaceName"] = value["target_keyspace_name"]
+    out["targetTableName"] = value["target_table_name"]
+    if "restore_timestamp" in value:
+        import capo_keyspaces.types.timestamp
+
+        out["restoreTimestamp"] = capo_keyspaces.types.timestamp.serialize_aws_json_1_0(
+            value["restore_timestamp"]
+        )
+    if "capacity_specification_override" in value:
+        import capo_keyspaces.types.capacity_specification
+
+        out["capacitySpecificationOverride"] = (
+            capo_keyspaces.types.capacity_specification.serialize_aws_json_1_0(
+                value["capacity_specification_override"]
+            )
+        )
+    if "encryption_specification_override" in value:
+        import capo_keyspaces.types.encryption_specification
+
+        out["encryptionSpecificationOverride"] = (
+            capo_keyspaces.types.encryption_specification.serialize_aws_json_1_0(
+                value["encryption_specification_override"]
+            )
+        )
+    if "point_in_time_recovery_override" in value:
+        import capo_keyspaces.types.point_in_time_recovery
+
+        out["pointInTimeRecoveryOverride"] = (
+            capo_keyspaces.types.point_in_time_recovery.serialize_aws_json_1_0(
+                value["point_in_time_recovery_override"]
+            )
+        )
+    if "tags_override" in value:
+        import capo_keyspaces.types.tag_list
+
+        out["tagsOverride"] = capo_keyspaces.types.tag_list.serialize_aws_json_1_0(
+            value["tags_override"]
+        )
+    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"]
+            )
+        )
+    if "replica_specifications" in value:
+        import capo_keyspaces.types.replica_specification_list
+
+        out["replicaSpecifications"] = (
+            capo_keyspaces.types.replica_specification_list.serialize_aws_json_1_0(
+                value["replica_specifications"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> RestoreTableRequest:
+    out: RestoreTableRequest = {}  # type: ignore[typeddict-item]
+    if data.get("sourceKeyspaceName") is not None:
+        out["source_keyspace_name"] = data["sourceKeyspaceName"]
+    else:
+        raise DeserializationError("RestoreTableRequest.source_keyspace_name required")
+    if data.get("sourceTableName") is not None:
+        out["source_table_name"] = data["sourceTableName"]
+    else:
+        raise DeserializationError("RestoreTableRequest.source_table_name required")
+    if data.get("targetKeyspaceName") is not None:
+        out["target_keyspace_name"] = data["targetKeyspaceName"]
+    else:
+        raise DeserializationError("RestoreTableRequest.target_keyspace_name required")
+    if data.get("targetTableName") is not None:
+        out["target_table_name"] = data["targetTableName"]
+    else:
+        raise DeserializationError("RestoreTableRequest.target_table_name required")
+    if data.get("restoreTimestamp") is not None:
+        import capo_keyspaces.types.timestamp
+
+        out["restore_timestamp"] = (
+            capo_keyspaces.types.timestamp.deserialize_aws_json_1_0(
+                data["restoreTimestamp"]
+            )
+        )
+    if data.get("capacitySpecificationOverride") is not None:
+        import capo_keyspaces.types.capacity_specification
+
+        out["capacity_specification_override"] = (
+            capo_keyspaces.types.capacity_specification.deserialize_aws_json_1_0(
+                data["capacitySpecificationOverride"]
+            )
+        )
+    if data.get("encryptionSpecificationOverride") is not None:
+        import capo_keyspaces.types.encryption_specification
+
+        out["encryption_specification_override"] = (
+            capo_keyspaces.types.encryption_specification.deserialize_aws_json_1_0(
+                data["encryptionSpecificationOverride"]
+            )
+        )
+    if data.get("pointInTimeRecoveryOverride") is not None:
+        import capo_keyspaces.types.point_in_time_recovery
+
+        out["point_in_time_recovery_override"] = (
+            capo_keyspaces.types.point_in_time_recovery.deserialize_aws_json_1_0(
+                data["pointInTimeRecoveryOverride"]
+            )
+        )
+    if data.get("tagsOverride") is not None:
+        import capo_keyspaces.types.tag_list
+
+        out["tags_override"] = capo_keyspaces.types.tag_list.deserialize_aws_json_1_0(
+            data["tagsOverride"]
+        )
+    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"]
+            )
+        )
+    if data.get("replicaSpecifications") is not None:
+        import capo_keyspaces.types.replica_specification_list
+
+        out["replica_specifications"] = (
+            capo_keyspaces.types.replica_specification_list.deserialize_aws_json_1_0(
+                data["replicaSpecifications"]
+            )
+        )
+    return out

capo_keyspaces/types/restore_table_response.py

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

capo_keyspaces/types/rs.py

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