capo-keyspacesstreams 0.1.0__py3-none-any.whl

capo_keyspacesstreams/types/keyspaces_cell_value.py

@@ -0,0 +1,333 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#KeyspacesCellValue``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_keyspacesstreams.errors import DeserializationError, SerializationError
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspaces_cell_list
+    import capo_keyspacesstreams.types.keyspaces_cell_map
+    import capo_keyspacesstreams.types.keyspaces_udt_map
+
+
+class _KeyspacesCellValue_asciiT(TypedDict, closed=True):
+    asciiT: "str"
+
+
+class _KeyspacesCellValue_bigintT(TypedDict, closed=True):
+    bigintT: "str"
+
+
+class _KeyspacesCellValue_blobT(TypedDict, closed=True):
+    blobT: "bytes"
+
+
+class _KeyspacesCellValue_boolT(TypedDict, closed=True):
+    boolT: "bool"
+
+
+class _KeyspacesCellValue_counterT(TypedDict, closed=True):
+    counterT: "str"
+
+
+class _KeyspacesCellValue_dateT(TypedDict, closed=True):
+    dateT: "str"
+
+
+class _KeyspacesCellValue_decimalT(TypedDict, closed=True):
+    decimalT: "str"
+
+
+class _KeyspacesCellValue_doubleT(TypedDict, closed=True):
+    doubleT: "str"
+
+
+class _KeyspacesCellValue_durationT(TypedDict, closed=True):
+    durationT: "str"
+
+
+class _KeyspacesCellValue_floatT(TypedDict, closed=True):
+    floatT: "str"
+
+
+class _KeyspacesCellValue_inetT(TypedDict, closed=True):
+    inetT: "str"
+
+
+class _KeyspacesCellValue_intT(TypedDict, closed=True):
+    intT: "str"
+
+
+class _KeyspacesCellValue_listT(TypedDict, closed=True):
+    listT: "capo_keyspacesstreams.types.keyspaces_cell_list.KeyspacesCellList"
+
+
+class _KeyspacesCellValue_mapT(TypedDict, closed=True):
+    mapT: "capo_keyspacesstreams.types.keyspaces_cell_map.KeyspacesCellMap"
+
+
+class _KeyspacesCellValue_setT(TypedDict, closed=True):
+    setT: "capo_keyspacesstreams.types.keyspaces_cell_list.KeyspacesCellList"
+
+
+class _KeyspacesCellValue_smallintT(TypedDict, closed=True):
+    smallintT: "str"
+
+
+class _KeyspacesCellValue_textT(TypedDict, closed=True):
+    textT: "str"
+
+
+class _KeyspacesCellValue_timeT(TypedDict, closed=True):
+    timeT: "str"
+
+
+class _KeyspacesCellValue_timestampT(TypedDict, closed=True):
+    timestampT: "str"
+
+
+class _KeyspacesCellValue_timeuuidT(TypedDict, closed=True):
+    timeuuidT: "str"
+
+
+class _KeyspacesCellValue_tinyintT(TypedDict, closed=True):
+    tinyintT: "str"
+
+
+class _KeyspacesCellValue_tupleT(TypedDict, closed=True):
+    tupleT: "capo_keyspacesstreams.types.keyspaces_cell_list.KeyspacesCellList"
+
+
+class _KeyspacesCellValue_uuidT(TypedDict, closed=True):
+    uuidT: "str"
+
+
+class _KeyspacesCellValue_varcharT(TypedDict, closed=True):
+    varcharT: "str"
+
+
+class _KeyspacesCellValue_varintT(TypedDict, closed=True):
+    varintT: "str"
+
+
+class _KeyspacesCellValue_udtT(TypedDict, closed=True):
+    udtT: "capo_keyspacesstreams.types.keyspaces_udt_map.KeyspacesUdtMap"
+
+
+KeyspacesCellValue: TypeAlias = (
+    _KeyspacesCellValue_asciiT
+    | _KeyspacesCellValue_bigintT
+    | _KeyspacesCellValue_blobT
+    | _KeyspacesCellValue_boolT
+    | _KeyspacesCellValue_counterT
+    | _KeyspacesCellValue_dateT
+    | _KeyspacesCellValue_decimalT
+    | _KeyspacesCellValue_doubleT
+    | _KeyspacesCellValue_durationT
+    | _KeyspacesCellValue_floatT
+    | _KeyspacesCellValue_inetT
+    | _KeyspacesCellValue_intT
+    | _KeyspacesCellValue_listT
+    | _KeyspacesCellValue_mapT
+    | _KeyspacesCellValue_setT
+    | _KeyspacesCellValue_smallintT
+    | _KeyspacesCellValue_textT
+    | _KeyspacesCellValue_timeT
+    | _KeyspacesCellValue_timestampT
+    | _KeyspacesCellValue_timeuuidT
+    | _KeyspacesCellValue_tinyintT
+    | _KeyspacesCellValue_tupleT
+    | _KeyspacesCellValue_uuidT
+    | _KeyspacesCellValue_varcharT
+    | _KeyspacesCellValue_varintT
+    | _KeyspacesCellValue_udtT
+)
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: KeyspacesCellValue) -> dict:
+    if "asciiT" in value:
+        return {"asciiT": value["asciiT"]}
+    elif "bigintT" in value:
+        return {"bigintT": value["bigintT"]}
+    elif "blobT" in value:
+        import capo_keyspacesstreams.types._prelude.blob
+
+        return {
+            "blobT": capo_keyspacesstreams.types._prelude.blob.serialize_aws_json_1_0(
+                value["blobT"]
+            )
+        }
+    elif "boolT" in value:
+        return {"boolT": value["boolT"]}
+    elif "counterT" in value:
+        return {"counterT": value["counterT"]}
+    elif "dateT" in value:
+        return {"dateT": value["dateT"]}
+    elif "decimalT" in value:
+        return {"decimalT": value["decimalT"]}
+    elif "doubleT" in value:
+        return {"doubleT": value["doubleT"]}
+    elif "durationT" in value:
+        return {"durationT": value["durationT"]}
+    elif "floatT" in value:
+        return {"floatT": value["floatT"]}
+    elif "inetT" in value:
+        return {"inetT": value["inetT"]}
+    elif "intT" in value:
+        return {"intT": value["intT"]}
+    elif "listT" in value:
+        import capo_keyspacesstreams.types.keyspaces_cell_list
+
+        return {
+            "listT": capo_keyspacesstreams.types.keyspaces_cell_list.serialize_aws_json_1_0(
+                value["listT"]
+            )
+        }
+    elif "mapT" in value:
+        import capo_keyspacesstreams.types.keyspaces_cell_map
+
+        return {
+            "mapT": capo_keyspacesstreams.types.keyspaces_cell_map.serialize_aws_json_1_0(
+                value["mapT"]
+            )
+        }
+    elif "setT" in value:
+        import capo_keyspacesstreams.types.keyspaces_cell_list
+
+        return {
+            "setT": capo_keyspacesstreams.types.keyspaces_cell_list.serialize_aws_json_1_0(
+                value["setT"]
+            )
+        }
+    elif "smallintT" in value:
+        return {"smallintT": value["smallintT"]}
+    elif "textT" in value:
+        return {"textT": value["textT"]}
+    elif "timeT" in value:
+        return {"timeT": value["timeT"]}
+    elif "timestampT" in value:
+        return {"timestampT": value["timestampT"]}
+    elif "timeuuidT" in value:
+        return {"timeuuidT": value["timeuuidT"]}
+    elif "tinyintT" in value:
+        return {"tinyintT": value["tinyintT"]}
+    elif "tupleT" in value:
+        import capo_keyspacesstreams.types.keyspaces_cell_list
+
+        return {
+            "tupleT": capo_keyspacesstreams.types.keyspaces_cell_list.serialize_aws_json_1_0(
+                value["tupleT"]
+            )
+        }
+    elif "uuidT" in value:
+        return {"uuidT": value["uuidT"]}
+    elif "varcharT" in value:
+        return {"varcharT": value["varcharT"]}
+    elif "varintT" in value:
+        return {"varintT": value["varintT"]}
+    elif "udtT" in value:
+        import capo_keyspacesstreams.types.keyspaces_udt_map
+
+        return {
+            "udtT": capo_keyspacesstreams.types.keyspaces_udt_map.serialize_aws_json_1_0(
+                value["udtT"]
+            )
+        }
+    else:
+        raise SerializationError("KeyspacesCellValue: no variant present")
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspacesCellValue:
+    if data.get("asciiT") is not None:
+        return {"asciiT": data["asciiT"]}
+    elif data.get("bigintT") is not None:
+        return {"bigintT": data["bigintT"]}
+    elif data.get("blobT") is not None:
+        import capo_keyspacesstreams.types._prelude.blob
+
+        return {
+            "blobT": capo_keyspacesstreams.types._prelude.blob.deserialize_aws_json_1_0(
+                data["blobT"]
+            )
+        }
+    elif data.get("boolT") is not None:
+        return {"boolT": data["boolT"]}
+    elif data.get("counterT") is not None:
+        return {"counterT": data["counterT"]}
+    elif data.get("dateT") is not None:
+        return {"dateT": data["dateT"]}
+    elif data.get("decimalT") is not None:
+        return {"decimalT": data["decimalT"]}
+    elif data.get("doubleT") is not None:
+        return {"doubleT": data["doubleT"]}
+    elif data.get("durationT") is not None:
+        return {"durationT": data["durationT"]}
+    elif data.get("floatT") is not None:
+        return {"floatT": data["floatT"]}
+    elif data.get("inetT") is not None:
+        return {"inetT": data["inetT"]}
+    elif data.get("intT") is not None:
+        return {"intT": data["intT"]}
+    elif data.get("listT") is not None:
+        import capo_keyspacesstreams.types.keyspaces_cell_list
+
+        return {
+            "listT": capo_keyspacesstreams.types.keyspaces_cell_list.deserialize_aws_json_1_0(
+                data["listT"]
+            )
+        }
+    elif data.get("mapT") is not None:
+        import capo_keyspacesstreams.types.keyspaces_cell_map
+
+        return {
+            "mapT": capo_keyspacesstreams.types.keyspaces_cell_map.deserialize_aws_json_1_0(
+                data["mapT"]
+            )
+        }
+    elif data.get("setT") is not None:
+        import capo_keyspacesstreams.types.keyspaces_cell_list
+
+        return {
+            "setT": capo_keyspacesstreams.types.keyspaces_cell_list.deserialize_aws_json_1_0(
+                data["setT"]
+            )
+        }
+    elif data.get("smallintT") is not None:
+        return {"smallintT": data["smallintT"]}
+    elif data.get("textT") is not None:
+        return {"textT": data["textT"]}
+    elif data.get("timeT") is not None:
+        return {"timeT": data["timeT"]}
+    elif data.get("timestampT") is not None:
+        return {"timestampT": data["timestampT"]}
+    elif data.get("timeuuidT") is not None:
+        return {"timeuuidT": data["timeuuidT"]}
+    elif data.get("tinyintT") is not None:
+        return {"tinyintT": data["tinyintT"]}
+    elif data.get("tupleT") is not None:
+        import capo_keyspacesstreams.types.keyspaces_cell_list
+
+        return {
+            "tupleT": capo_keyspacesstreams.types.keyspaces_cell_list.deserialize_aws_json_1_0(
+                data["tupleT"]
+            )
+        }
+    elif data.get("uuidT") is not None:
+        return {"uuidT": data["uuidT"]}
+    elif data.get("varcharT") is not None:
+        return {"varcharT": data["varcharT"]}
+    elif data.get("varintT") is not None:
+        return {"varintT": data["varintT"]}
+    elif data.get("udtT") is not None:
+        import capo_keyspacesstreams.types.keyspaces_udt_map
+
+        return {
+            "udtT": capo_keyspacesstreams.types.keyspaces_udt_map.deserialize_aws_json_1_0(
+                data["udtT"]
+            )
+        }
+    else:
+        raise DeserializationError("KeyspacesCellValue: no recognized variant key")

capo_keyspacesstreams/types/keyspaces_cells.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#KeyspacesCells``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspaces_cell
+
+KeyspacesCells: TypeAlias = dict[
+    "str", "capo_keyspacesstreams.types.keyspaces_cell.KeyspacesCell"
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(input_to_serialize: KeyspacesCells) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_keyspacesstreams.types.keyspaces_cell
+
+        out[key] = capo_keyspacesstreams.types.keyspaces_cell.serialize_aws_json_1_0(
+            value
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspacesCells:
+    out: KeyspacesCells = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        import capo_keyspacesstreams.types.keyspaces_cell
+
+        out[key] = capo_keyspacesstreams.types.keyspaces_cell.deserialize_aws_json_1_0(
+            value
+        )
+    return out

capo_keyspacesstreams/types/keyspaces_keys_map.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#KeyspacesKeysMap``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspaces_cell_value
+
+KeyspacesKeysMap: TypeAlias = dict[
+    "str", "capo_keyspacesstreams.types.keyspaces_cell_value.KeyspacesCellValue"
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(input_to_serialize: KeyspacesKeysMap) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_keyspacesstreams.types.keyspaces_cell_value
+
+        out[key] = (
+            capo_keyspacesstreams.types.keyspaces_cell_value.serialize_aws_json_1_0(
+                value
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspacesKeysMap:
+    out: KeyspacesKeysMap = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        import capo_keyspacesstreams.types.keyspaces_cell_value
+
+        out[key] = (
+            capo_keyspacesstreams.types.keyspaces_cell_value.deserialize_aws_json_1_0(
+                value
+            )
+        )
+    return out

capo_keyspacesstreams/types/keyspaces_metadata.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#KeyspacesMetadata``."""
+
+from typing_extensions import NotRequired, TypedDict
+
+
+class KeyspacesMetadata(TypedDict, closed=True):
+    expiration_time: NotRequired["str"]
+    """<p>The time at which the associated data will expire, based on the time-to-live (TTL) setting.</p>"""
+    write_time: NotRequired["str"]
+    """<p>The timestamp at which the associated data was written to the database.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: KeyspacesMetadata) -> dict:
+    out: dict = {}
+    if "expiration_time" in value:
+        out["expirationTime"] = value["expiration_time"]
+    if "write_time" in value:
+        out["writeTime"] = value["write_time"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspacesMetadata:
+    out: KeyspacesMetadata = {}  # type: ignore[typeddict-item]
+    if data.get("expirationTime") is not None:
+        out["expiration_time"] = data["expirationTime"]
+    if data.get("writeTime") is not None:
+        out["write_time"] = data["writeTime"]
+    return out

capo_keyspacesstreams/types/keyspaces_row.py

@@ -0,0 +1,83 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#KeyspacesRow``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspaces_cells
+    import capo_keyspacesstreams.types.keyspaces_metadata
+
+
+class KeyspacesRow(TypedDict, closed=True):
+    value_cells: NotRequired[
+        "capo_keyspacesstreams.types.keyspaces_cells.KeyspacesCells"
+    ]
+    """<p>A map of regular (non-static) column cells in the row, where keys are column names and values are the corresponding cells.</p>"""
+    static_cells: NotRequired[
+        "capo_keyspacesstreams.types.keyspaces_cells.KeyspacesCells"
+    ]
+    """<p>A map of static column cells shared by all rows with the same partition key, where keys are column names and values are the corresponding cells.</p>"""
+    row_metadata: NotRequired[
+        "capo_keyspacesstreams.types.keyspaces_metadata.KeyspacesMetadata"
+    ]
+    """<p>Metadata that applies to the entire row, such as timestamps and TTL information.</p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: KeyspacesRow) -> dict:
+    out: dict = {}
+    if "value_cells" in value:
+        import capo_keyspacesstreams.types.keyspaces_cells
+
+        out["valueCells"] = (
+            capo_keyspacesstreams.types.keyspaces_cells.serialize_aws_json_1_0(
+                value["value_cells"]
+            )
+        )
+    if "static_cells" in value:
+        import capo_keyspacesstreams.types.keyspaces_cells
+
+        out["staticCells"] = (
+            capo_keyspacesstreams.types.keyspaces_cells.serialize_aws_json_1_0(
+                value["static_cells"]
+            )
+        )
+    if "row_metadata" in value:
+        import capo_keyspacesstreams.types.keyspaces_metadata
+
+        out["rowMetadata"] = (
+            capo_keyspacesstreams.types.keyspaces_metadata.serialize_aws_json_1_0(
+                value["row_metadata"]
+            )
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspacesRow:
+    out: KeyspacesRow = {}  # type: ignore[typeddict-item]
+    if data.get("valueCells") is not None:
+        import capo_keyspacesstreams.types.keyspaces_cells
+
+        out["value_cells"] = (
+            capo_keyspacesstreams.types.keyspaces_cells.deserialize_aws_json_1_0(
+                data["valueCells"]
+            )
+        )
+    if data.get("staticCells") is not None:
+        import capo_keyspacesstreams.types.keyspaces_cells
+
+        out["static_cells"] = (
+            capo_keyspacesstreams.types.keyspaces_cells.deserialize_aws_json_1_0(
+                data["staticCells"]
+            )
+        )
+    if data.get("rowMetadata") is not None:
+        import capo_keyspacesstreams.types.keyspaces_metadata
+
+        out["row_metadata"] = (
+            capo_keyspacesstreams.types.keyspaces_metadata.deserialize_aws_json_1_0(
+                data["rowMetadata"]
+            )
+        )
+    return out

capo_keyspacesstreams/types/keyspaces_udt_map.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#KeyspacesUdtMap``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspaces_cell
+
+KeyspacesUdtMap: TypeAlias = dict[
+    "str", "capo_keyspacesstreams.types.keyspaces_cell.KeyspacesCell"
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(input_to_serialize: KeyspacesUdtMap) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_keyspacesstreams.types.keyspaces_cell
+
+        out[key] = capo_keyspacesstreams.types.keyspaces_cell.serialize_aws_json_1_0(
+            value
+        )
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> KeyspacesUdtMap:
+    out: KeyspacesUdtMap = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        import capo_keyspacesstreams.types.keyspaces_cell
+
+        out[key] = capo_keyspacesstreams.types.keyspaces_cell.deserialize_aws_json_1_0(
+            value
+        )
+    return out

capo_keyspacesstreams/types/list_streams_input.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ListStreamsInput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.keyspace_name
+    import capo_keyspacesstreams.types.stream_arn_token
+    import capo_keyspacesstreams.types.table_name
+
+
+class ListStreamsInput(TypedDict, closed=True):
+    keyspace_name: NotRequired["capo_keyspacesstreams.types.keyspace_name.KeyspaceName"]
+    """<p> The name of the keyspace for which to list streams. If specified, only streams associated with tables in this keyspace are returned. If omitted, streams from all keyspaces are included in the results. </p>"""
+    table_name: NotRequired["capo_keyspacesstreams.types.table_name.TableName"]
+    """<p> The name of the table for which to list streams. Must be used together with <code>keyspaceName</code>. If specified, only streams associated with this specific table are returned. </p>"""
+    max_results: NotRequired["int"]
+    """<p> The maximum number of streams to return in a single <code>ListStreams</code> request. The default value is 100. The minimum value is 1 and the maximum value is 100. </p>"""
+    next_token: NotRequired[
+        "capo_keyspacesstreams.types.stream_arn_token.StreamArnToken"
+    ]
+    """<p> An optional pagination token provided by a previous <code>ListStreams</code> operation. If this parameter is specified, the response includes only records beyond the token, up to the value specified by <code>maxResults</code>. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListStreamsInput) -> dict:
+    out: dict = {}
+    if "keyspace_name" in value:
+        out["keyspaceName"] = value["keyspace_name"]
+    if "table_name" in value:
+        out["tableName"] = value["table_name"]
+    if "max_results" in value:
+        out["maxResults"] = value["max_results"]
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListStreamsInput:
+    out: ListStreamsInput = {}  # type: ignore[typeddict-item]
+    if data.get("keyspaceName") is not None:
+        out["keyspace_name"] = data["keyspaceName"]
+    if data.get("tableName") is not None:
+        out["table_name"] = data["tableName"]
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_keyspacesstreams/types/list_streams_output.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#ListStreamsOutput``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_keyspacesstreams.types.stream_arn_token
+    import capo_keyspacesstreams.types.stream_list
+
+
+class ListStreamsOutput(TypedDict, closed=True):
+    streams: NotRequired["capo_keyspacesstreams.types.stream_list.StreamList"]
+    """<p> An array of stream objects, each containing summary information about a stream including its ARN, status, and associated table information. This list includes all streams that match the request criteria. </p>"""
+    next_token: NotRequired[
+        "capo_keyspacesstreams.types.stream_arn_token.StreamArnToken"
+    ]
+    """<p> A pagination token that can be used in a subsequent <code>ListStreams</code> request. This token is returned if the response contains more streams than can be returned in a single response based on the <code>maxResults</code> parameter. </p>"""
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: ListStreamsOutput) -> dict:
+    out: dict = {}
+    if "streams" in value:
+        import capo_keyspacesstreams.types.stream_list
+
+        out["streams"] = capo_keyspacesstreams.types.stream_list.serialize_aws_json_1_0(
+            value["streams"]
+        )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_aws_json_1_0(data: dict) -> ListStreamsOutput:
+    out: ListStreamsOutput = {}  # type: ignore[typeddict-item]
+    if data.get("streams") is not None:
+        import capo_keyspacesstreams.types.stream_list
+
+        out["streams"] = (
+            capo_keyspacesstreams.types.stream_list.deserialize_aws_json_1_0(
+                data["streams"]
+            )
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_keyspacesstreams/types/origin_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.keyspacesstreams#OriginType``."""
+
+from typing import Literal, TypeAlias, cast
+
+OriginType: TypeAlias = Literal[
+    "USER",
+    "REPLICATION",
+    "TTL",
+]
+
+
+# --- awsJson1_0 ser/de ---
+def serialize_aws_json_1_0(value: OriginType) -> str:
+    return value
+
+
+def deserialize_aws_json_1_0(data: str) -> OriginType:
+    return cast(OriginType, data)