capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/invocation_response.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvocationResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.blob
+    import capo_lambda.types.durable_execution_arn
+    import capo_lambda.types.integer
+    import capo_lambda.types.string
+    import capo_lambda.types.version
+
+
+class InvocationResponse(TypedDict, closed=True):
+    status_code: "capo_lambda.types.integer.Integer"
+    """<p>The HTTP status code is in the 200 range for a successful request. For the <code>RequestResponse</code> invocation type, this status code is 200. For the <code>Event</code> invocation type, this status code is 202. For the <code>DryRun</code> invocation type, the status code is 204.</p>"""
+    function_error: NotRequired["capo_lambda.types.string.String"]
+    """<p>If present, indicates that an error occurred during function execution. Details about the error are included in the response payload.</p>"""
+    log_result: NotRequired["capo_lambda.types.string.String"]
+    """<p>The last 4 KB of the execution log, which is base64-encoded.</p>"""
+    payload: NotRequired["capo_lambda.types.blob.Blob"]
+    """<p>The response from the function, or an error object.</p>"""
+    executed_version: NotRequired["capo_lambda.types.version.Version"]
+    """<p>The version of the function that executed. When you invoke a function with an alias, this indicates which version the alias resolved to.</p>"""
+    durable_execution_arn: NotRequired[
+        "capo_lambda.types.durable_execution_arn.DurableExecutionArn"
+    ]
+    """<p>The ARN of the durable execution that was started. This is returned when invoking a durable function and provides a unique identifier for tracking the execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvocationResponse) -> dict:
+    out: dict = {}
+    if "payload" in value:
+        import capo_lambda.types.blob
+
+        out["Payload"] = capo_lambda.types.blob.serialize_json(value["payload"])
+    return out
+
+
+def deserialize_json(data: dict) -> InvocationResponse:
+    out: InvocationResponse = {}  # type: ignore[typeddict-item]
+    if "Payload" in data:
+        import capo_lambda.types.blob
+
+        out["payload"] = capo_lambda.types.blob.deserialize_json(data["Payload"])
+    return out

capo_lambda/types/invocation_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvocationType``."""
+
+from typing import Literal, TypeAlias, cast
+
+InvocationType: TypeAlias = Literal[
+    "Event",
+    "RequestResponse",
+    "DryRun",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvocationType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> InvocationType:
+    return cast(InvocationType, data)

capo_lambda/types/invoke_async_request.py

@@ -0,0 +1,16 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeAsyncRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.blob_stream
+    import capo_lambda.types.namespaced_function_name
+
+
+class InvokeAsyncRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    r"""<p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    invoke_args: "capo_lambda.types.blob_stream.BlobStream"
+    """<p>The JSON that you want to provide to your Lambda function as input.</p>"""

capo_lambda/types/invoke_async_response.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeAsyncResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.http_status
+
+
+class InvokeAsyncResponse(TypedDict, closed=True):
+    status: "capo_lambda.types.http_status.HttpStatus"
+    """<p>The status code.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvokeAsyncResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> InvokeAsyncResponse:
+    out: InvokeAsyncResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/invoke_mode.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeMode``."""
+
+from typing import Literal, TypeAlias, cast
+
+InvokeMode: TypeAlias = Literal[
+    "BUFFERED",
+    "RESPONSE_STREAM",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvokeMode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> InvokeMode:
+    return cast(InvokeMode, data)

capo_lambda/types/invoke_response_stream_update.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeResponseStreamUpdate``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda._protocol.eventstream import HeaderValue, Message
+
+if TYPE_CHECKING:
+    import capo_lambda.types.blob
+
+
+class InvokeResponseStreamUpdate(TypedDict, closed=True):
+    payload: NotRequired["capo_lambda.types.blob.Blob"]
+    """<p>Data returned by your Lambda function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvokeResponseStreamUpdate) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> InvokeResponseStreamUpdate:
+    out: InvokeResponseStreamUpdate = {}  # type: ignore[typeddict-item]
+    return out
+
+
+def serialize_event_json(value: InvokeResponseStreamUpdate) -> bytes:
+    headers: dict[str, HeaderValue] = {":event-type": "PayloadChunk"}
+    payload = b""
+    payload = value["payload"]
+    return Message(headers=headers, payload=payload).encode()
+
+
+def deserialize_event_json(message: Message) -> InvokeResponseStreamUpdate:
+    headers = message.headers  # noqa: F841
+    payload = message.payload  # noqa: F841
+    out: InvokeResponseStreamUpdate = {}  # type: ignore[typeddict-item]
+    if payload:
+        out["payload"] = payload
+    return out

capo_lambda/types/invoke_with_response_stream_complete_event.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeWithResponseStreamCompleteEvent``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda._protocol.eventstream import HeaderValue, Message
+
+if TYPE_CHECKING:
+    import capo_lambda.types.string
+
+
+class InvokeWithResponseStreamCompleteEvent(TypedDict, closed=True):
+    error_code: NotRequired["capo_lambda.types.string.String"]
+    """<p>An error code.</p>"""
+    error_details: NotRequired["capo_lambda.types.string.String"]
+    """<p>The details of any returned error.</p>"""
+    log_result: NotRequired["capo_lambda.types.string.String"]
+    """<p>The last 4 KB of the execution log, which is base64-encoded.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvokeWithResponseStreamCompleteEvent) -> dict:
+    out: dict = {}
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    if "error_details" in value:
+        out["ErrorDetails"] = value["error_details"]
+    if "log_result" in value:
+        out["LogResult"] = value["log_result"]
+    return out
+
+
+def deserialize_json(data: dict) -> InvokeWithResponseStreamCompleteEvent:
+    out: InvokeWithResponseStreamCompleteEvent = {}  # type: ignore[typeddict-item]
+    if "ErrorCode" in data:
+        out["error_code"] = data["ErrorCode"]
+    if "ErrorDetails" in data:
+        out["error_details"] = data["ErrorDetails"]
+    if "LogResult" in data:
+        out["log_result"] = data["LogResult"]
+    return out
+
+
+def serialize_event_json(value: InvokeWithResponseStreamCompleteEvent) -> bytes:
+    headers: dict[str, HeaderValue] = {":event-type": "InvokeComplete"}
+    payload = b""
+    return Message(headers=headers, payload=payload).encode()
+
+
+def deserialize_event_json(message: Message) -> InvokeWithResponseStreamCompleteEvent:
+    headers = message.headers  # noqa: F841
+    payload = message.payload  # noqa: F841
+    out: InvokeWithResponseStreamCompleteEvent = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/invoke_with_response_stream_request.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeWithResponseStreamRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.blob
+    import capo_lambda.types.log_type
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+    import capo_lambda.types.response_streaming_invocation_type
+    import capo_lambda.types.string
+    import capo_lambda.types.tenant_id
+
+
+class InvokeWithResponseStreamRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    r"""<p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    invocation_type: NotRequired[
+        "capo_lambda.types.response_streaming_invocation_type.ResponseStreamingInvocationType"
+    ]
+    """<p>Use one of the following options:</p> <ul> <li> <p> <code>RequestResponse</code> (default) – Invoke the function synchronously. Keep the connection open until the function returns a response or times out. The API operation response includes the function response and additional data.</p> </li> <li> <p> <code>DryRun</code> – Validate parameter values and verify that the IAM user or role has permission to invoke the function.</p> </li> </ul>"""
+    log_type: NotRequired["capo_lambda.types.log_type.LogType"]
+    """<p>Set to <code>Tail</code> to include the execution log in the response. Applies to synchronously invoked functions only.</p>"""
+    client_context: NotRequired["capo_lambda.types.string.String"]
+    """<p>Up to 3,583 bytes of base64-encoded data about the invoking client to pass to the function in the context object.</p>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>The alias name.</p>"""
+    payload: NotRequired["capo_lambda.types.blob.Blob"]
+    r"""<p>The JSON that you want to provide to your Lambda function as input.</p> <p>You can enter the JSON directly. For example, <code>--payload '{ \"key\": \"value\" }'</code>. You can also specify a file path. For example, <code>--payload file://payload.json</code>.</p>"""
+    tenant_id: NotRequired["capo_lambda.types.tenant_id.TenantId"]
+    """<p>The identifier of the tenant in a multi-tenant Lambda function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvokeWithResponseStreamRequest) -> dict:
+    out: dict = {}
+    if "payload" in value:
+        import capo_lambda.types.blob
+
+        out["Payload"] = capo_lambda.types.blob.serialize_json(value["payload"])
+    return out
+
+
+def deserialize_json(data: dict) -> InvokeWithResponseStreamRequest:
+    out: InvokeWithResponseStreamRequest = {}  # type: ignore[typeddict-item]
+    if "Payload" in data:
+        import capo_lambda.types.blob
+
+        out["payload"] = capo_lambda.types.blob.deserialize_json(data["Payload"])
+    return out

capo_lambda/types/invoke_with_response_stream_response.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeWithResponseStreamResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.integer
+    import capo_lambda.types.invoke_with_response_stream_response_event
+    import capo_lambda.types.string
+    import capo_lambda.types.version
+
+
+class InvokeWithResponseStreamResponse(TypedDict, closed=True):
+    status_code: "capo_lambda.types.integer.Integer"
+    """<p>For a successful request, the HTTP status code is in the 200 range. For the <code>RequestResponse</code> invocation type, this status code is 200. For the <code>DryRun</code> invocation type, this status code is 204.</p>"""
+    executed_version: NotRequired["capo_lambda.types.version.Version"]
+    """<p>The version of the function that executed. When you invoke a function with an alias, this indicates which version the alias resolved to.</p>"""
+    event_stream: NotRequired[
+        "capo_lambda.types.invoke_with_response_stream_response_event.InvokeWithResponseStreamResponseEvent"
+    ]
+    """<p>The stream of response payloads.</p>"""
+    response_stream_content_type: NotRequired["capo_lambda.types.string.String"]
+    """<p>The type of data the stream is returning.</p>"""

capo_lambda/types/invoke_with_response_stream_response_event.py

@@ -0,0 +1,78 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokeWithResponseStreamResponseEvent``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+from typing_extensions import TypedDict
+
+from capo_lambda._iter import AnyIterator
+from capo_lambda._protocol.eventstream import Message
+
+if TYPE_CHECKING:
+    import capo_lambda.types.invoke_response_stream_update
+    import capo_lambda.types.invoke_with_response_stream_complete_event
+
+
+class _InvokeWithResponseStreamResponseEvent_PayloadChunk(TypedDict, closed=True):
+    PayloadChunk: (
+        "capo_lambda.types.invoke_response_stream_update.InvokeResponseStreamUpdate"
+    )
+
+
+class _InvokeWithResponseStreamResponseEvent_InvokeComplete(TypedDict, closed=True):
+    InvokeComplete: "capo_lambda.types.invoke_with_response_stream_complete_event.InvokeWithResponseStreamCompleteEvent"
+
+
+_InvokeWithResponseStreamResponseEvent: TypeAlias = (
+    _InvokeWithResponseStreamResponseEvent_PayloadChunk
+    | _InvokeWithResponseStreamResponseEvent_InvokeComplete
+)
+InvokeWithResponseStreamResponseEvent: TypeAlias = AnyIterator[
+    _InvokeWithResponseStreamResponseEvent
+]
+
+
+def serialize_event_json(value: _InvokeWithResponseStreamResponseEvent) -> bytes:
+    match value:
+        case {"PayloadChunk": payload}:
+            import capo_lambda.types.invoke_response_stream_update
+
+            return capo_lambda.types.invoke_response_stream_update.serialize_event_json(
+                payload
+            )
+        case {"InvokeComplete": payload}:
+            import capo_lambda.types.invoke_with_response_stream_complete_event
+
+            return capo_lambda.types.invoke_with_response_stream_complete_event.serialize_event_json(
+                payload
+            )
+        case _:
+            raise ValueError(
+                f"InvokeWithResponseStreamResponseEvent: unrecognized variant {value!r}"
+            )
+
+
+def deserialize_event_json(message: Message) -> _InvokeWithResponseStreamResponseEvent:
+    headers = message.headers
+    message_type = headers.get(":message-type", "event")  # noqa: F841
+    event_type = headers.get(":event-type")
+    match event_type:
+        case "PayloadChunk":
+            import capo_lambda.types.invoke_response_stream_update
+
+            return {
+                "PayloadChunk": capo_lambda.types.invoke_response_stream_update.deserialize_event_json(
+                    message
+                )
+            }
+        case "InvokeComplete":
+            import capo_lambda.types.invoke_with_response_stream_complete_event
+
+            return {
+                "InvokeComplete": capo_lambda.types.invoke_with_response_stream_complete_event.deserialize_event_json(
+                    message
+                )
+            }
+        case _:
+            raise ValueError(
+                f"InvokeWithResponseStreamResponseEvent: unrecognized event-type {event_type!r}"
+            )

capo_lambda/types/invoked_via_function_url.py

@@ -0,0 +1,5 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvokedViaFunctionUrl``."""
+
+from typing import TypeAlias
+
+InvokedViaFunctionUrl: TypeAlias = bool

capo_lambda/types/item_count.py

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

capo_lambda/types/kafka_schema_registry_access_config.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaRegistryAccessConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.arn
+    import capo_lambda.types.kafka_schema_registry_auth_type
+
+
+class KafkaSchemaRegistryAccessConfig(TypedDict, closed=True):
+    type: NotRequired[
+        "capo_lambda.types.kafka_schema_registry_auth_type.KafkaSchemaRegistryAuthType"
+    ]
+    """<p> The type of authentication Lambda uses to access your schema registry. </p>"""
+    uri: NotRequired["capo_lambda.types.arn.Arn"]
+    """<p> The URI of the secret (Secrets Manager secret ARN) to authenticate with your schema registry. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaRegistryAccessConfig) -> dict:
+    out: dict = {}
+    if "type" in value:
+        import capo_lambda.types.kafka_schema_registry_auth_type
+
+        out["Type"] = capo_lambda.types.kafka_schema_registry_auth_type.serialize_json(
+            value["type"]
+        )
+    if "uri" in value:
+        out["URI"] = value["uri"]
+    return out
+
+
+def deserialize_json(data: dict) -> KafkaSchemaRegistryAccessConfig:
+    out: KafkaSchemaRegistryAccessConfig = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        import capo_lambda.types.kafka_schema_registry_auth_type
+
+        out["type"] = (
+            capo_lambda.types.kafka_schema_registry_auth_type.deserialize_json(
+                data["Type"]
+            )
+        )
+    if "URI" in data:
+        out["uri"] = data["URI"]
+    return out

capo_lambda/types/kafka_schema_registry_access_config_list.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaRegistryAccessConfigList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.kafka_schema_registry_access_config
+
+KafkaSchemaRegistryAccessConfigList: TypeAlias = list[
+    "capo_lambda.types.kafka_schema_registry_access_config.KafkaSchemaRegistryAccessConfig"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaRegistryAccessConfigList) -> list:
+    import capo_lambda.types.kafka_schema_registry_access_config
+
+    out: list = []
+    for item in value:
+        out.append(
+            capo_lambda.types.kafka_schema_registry_access_config.serialize_json(item)
+        )
+    return out
+
+
+def deserialize_json(data: list) -> KafkaSchemaRegistryAccessConfigList:
+    import capo_lambda.types.kafka_schema_registry_access_config
+
+    out: KafkaSchemaRegistryAccessConfigList = []
+    for item in data:
+        out.append(
+            capo_lambda.types.kafka_schema_registry_access_config.deserialize_json(item)
+        )
+    return out

capo_lambda/types/kafka_schema_registry_auth_type.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaRegistryAuthType``."""
+
+from typing import Literal, TypeAlias, cast
+
+KafkaSchemaRegistryAuthType: TypeAlias = Literal[
+    "BASIC_AUTH",
+    "CLIENT_CERTIFICATE_TLS_AUTH",
+    "SERVER_ROOT_CA_CERTIFICATE",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaRegistryAuthType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> KafkaSchemaRegistryAuthType:
+    return cast(KafkaSchemaRegistryAuthType, data)

capo_lambda/types/kafka_schema_registry_config.py

@@ -0,0 +1,93 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaRegistryConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.kafka_schema_registry_access_config_list
+    import capo_lambda.types.kafka_schema_validation_config_list
+    import capo_lambda.types.schema_registry_event_record_format
+    import capo_lambda.types.schema_registry_uri
+
+
+class KafkaSchemaRegistryConfig(TypedDict, closed=True):
+    schema_registry_uri: NotRequired[
+        "capo_lambda.types.schema_registry_uri.SchemaRegistryUri"
+    ]
+    """<p>The URI for your schema registry. The correct URI format depends on the type of schema registry you're using.</p> <ul> <li> <p>For Glue schema registries, use the ARN of the registry.</p> </li> <li> <p>For Confluent schema registries, use the URL of the registry.</p> </li> </ul>"""
+    event_record_format: NotRequired[
+        "capo_lambda.types.schema_registry_event_record_format.SchemaRegistryEventRecordFormat"
+    ]
+    """<p>The record format that Lambda delivers to your function after schema validation.</p> <ul> <li> <p>Choose <code>JSON</code> to have Lambda deliver the record to your function as a standard JSON object.</p> </li> <li> <p>Choose <code>SOURCE</code> to have Lambda deliver the record to your function in its original source format. Lambda removes all schema metadata, such as the schema ID, before sending the record to your function.</p> </li> </ul>"""
+    access_configs: NotRequired[
+        "capo_lambda.types.kafka_schema_registry_access_config_list.KafkaSchemaRegistryAccessConfigList"
+    ]
+    """<p>An array of access configuration objects that tell Lambda how to authenticate with your schema registry.</p>"""
+    schema_validation_configs: NotRequired[
+        "capo_lambda.types.kafka_schema_validation_config_list.KafkaSchemaValidationConfigList"
+    ]
+    """<p>An array of schema validation configuration objects, which tell Lambda the message attributes you want to validate and filter using your schema registry.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaRegistryConfig) -> dict:
+    out: dict = {}
+    if "schema_registry_uri" in value:
+        out["SchemaRegistryURI"] = value["schema_registry_uri"]
+    if "event_record_format" in value:
+        import capo_lambda.types.schema_registry_event_record_format
+
+        out["EventRecordFormat"] = (
+            capo_lambda.types.schema_registry_event_record_format.serialize_json(
+                value["event_record_format"]
+            )
+        )
+    if "access_configs" in value:
+        import capo_lambda.types.kafka_schema_registry_access_config_list
+
+        out["AccessConfigs"] = (
+            capo_lambda.types.kafka_schema_registry_access_config_list.serialize_json(
+                value["access_configs"]
+            )
+        )
+    if "schema_validation_configs" in value:
+        import capo_lambda.types.kafka_schema_validation_config_list
+
+        out["SchemaValidationConfigs"] = (
+            capo_lambda.types.kafka_schema_validation_config_list.serialize_json(
+                value["schema_validation_configs"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> KafkaSchemaRegistryConfig:
+    out: KafkaSchemaRegistryConfig = {}  # type: ignore[typeddict-item]
+    if "SchemaRegistryURI" in data:
+        out["schema_registry_uri"] = data["SchemaRegistryURI"]
+    if "EventRecordFormat" in data:
+        import capo_lambda.types.schema_registry_event_record_format
+
+        out["event_record_format"] = (
+            capo_lambda.types.schema_registry_event_record_format.deserialize_json(
+                data["EventRecordFormat"]
+            )
+        )
+    if "AccessConfigs" in data:
+        import capo_lambda.types.kafka_schema_registry_access_config_list
+
+        out["access_configs"] = (
+            capo_lambda.types.kafka_schema_registry_access_config_list.deserialize_json(
+                data["AccessConfigs"]
+            )
+        )
+    if "SchemaValidationConfigs" in data:
+        import capo_lambda.types.kafka_schema_validation_config_list
+
+        out["schema_validation_configs"] = (
+            capo_lambda.types.kafka_schema_validation_config_list.deserialize_json(
+                data["SchemaValidationConfigs"]
+            )
+        )
+    return out

capo_lambda/types/kafka_schema_validation_attribute.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaValidationAttribute``."""
+
+from typing import Literal, TypeAlias, cast
+
+KafkaSchemaValidationAttribute: TypeAlias = Literal[
+    "KEY",
+    "VALUE",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaValidationAttribute) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> KafkaSchemaValidationAttribute:
+    return cast(KafkaSchemaValidationAttribute, data)

capo_lambda/types/kafka_schema_validation_config.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaValidationConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.kafka_schema_validation_attribute
+
+
+class KafkaSchemaValidationConfig(TypedDict, closed=True):
+    attribute: NotRequired[
+        "capo_lambda.types.kafka_schema_validation_attribute.KafkaSchemaValidationAttribute"
+    ]
+    """<p> The attributes you want your schema registry to validate and filter for. If you selected <code>JSON</code> as the <code>EventRecordFormat</code>, Lambda also deserializes the selected message attributes. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaValidationConfig) -> dict:
+    out: dict = {}
+    if "attribute" in value:
+        import capo_lambda.types.kafka_schema_validation_attribute
+
+        out["Attribute"] = (
+            capo_lambda.types.kafka_schema_validation_attribute.serialize_json(
+                value["attribute"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> KafkaSchemaValidationConfig:
+    out: KafkaSchemaValidationConfig = {}  # type: ignore[typeddict-item]
+    if "Attribute" in data:
+        import capo_lambda.types.kafka_schema_validation_attribute
+
+        out["attribute"] = (
+            capo_lambda.types.kafka_schema_validation_attribute.deserialize_json(
+                data["Attribute"]
+            )
+        )
+    return out