capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/schema_registry_uri.py

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

capo_lambda/types/security_group_id.py

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

capo_lambda/types/security_group_ids.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SecurityGroupIds``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.security_group_id
+
+SecurityGroupIds: TypeAlias = list[
+    "capo_lambda.types.security_group_id.SecurityGroupId"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SecurityGroupIds) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> SecurityGroupIds:
+    return list(data)

capo_lambda/types/self_managed_event_source.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SelfManagedEventSource``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.endpoints
+
+
+class SelfManagedEventSource(TypedDict, closed=True):
+    endpoints: NotRequired["capo_lambda.types.endpoints.Endpoints"]
+    r"""<p>The list of bootstrap servers for your Kafka brokers in the following format: <code>\"KAFKA_BOOTSTRAP_SERVERS\": [\"abc.xyz.com:xxxx\",\"abc2.xyz.com:xxxx\"]</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SelfManagedEventSource) -> dict:
+    out: dict = {}
+    if "endpoints" in value:
+        import capo_lambda.types.endpoints
+
+        out["Endpoints"] = capo_lambda.types.endpoints.serialize_json(
+            value["endpoints"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SelfManagedEventSource:
+    out: SelfManagedEventSource = {}  # type: ignore[typeddict-item]
+    if "Endpoints" in data:
+        import capo_lambda.types.endpoints
+
+        out["endpoints"] = capo_lambda.types.endpoints.deserialize_json(
+            data["Endpoints"]
+        )
+    return out

capo_lambda/types/self_managed_kafka_event_source_config.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SelfManagedKafkaEventSourceConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.kafka_schema_registry_config
+    import capo_lambda.types.uri
+
+
+class SelfManagedKafkaEventSourceConfig(TypedDict, closed=True):
+    consumer_group_id: NotRequired["capo_lambda.types.uri.URI"]
+    r"""<p> The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/with-kafka-process.html#services-smaa-topic-add\">Customizable consumer group ID</a>.</p>"""
+    schema_registry_config: NotRequired[
+        "capo_lambda.types.kafka_schema_registry_config.KafkaSchemaRegistryConfig"
+    ]
+    """<p>Specific configuration settings for a Kafka schema registry.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SelfManagedKafkaEventSourceConfig) -> dict:
+    out: dict = {}
+    if "consumer_group_id" in value:
+        out["ConsumerGroupId"] = value["consumer_group_id"]
+    if "schema_registry_config" in value:
+        import capo_lambda.types.kafka_schema_registry_config
+
+        out["SchemaRegistryConfig"] = (
+            capo_lambda.types.kafka_schema_registry_config.serialize_json(
+                value["schema_registry_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SelfManagedKafkaEventSourceConfig:
+    out: SelfManagedKafkaEventSourceConfig = {}  # type: ignore[typeddict-item]
+    if "ConsumerGroupId" in data:
+        out["consumer_group_id"] = data["ConsumerGroupId"]
+    if "SchemaRegistryConfig" in data:
+        import capo_lambda.types.kafka_schema_registry_config
+
+        out["schema_registry_config"] = (
+            capo_lambda.types.kafka_schema_registry_config.deserialize_json(
+                data["SchemaRegistryConfig"]
+            )
+        )
+    return out

capo_lambda/types/send_durable_execution_callback_failure_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackFailureRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.callback_id
+    import capo_lambda.types.error_object
+
+
+class SendDurableExecutionCallbackFailureRequest(TypedDict, closed=True):
+    callback_id: "capo_lambda.types.callback_id.CallbackId"
+    """<p>The unique identifier for the callback operation.</p>"""
+    error: NotRequired["capo_lambda.types.error_object.ErrorObject"]
+    """<p>Error details describing why the callback operation failed.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackFailureRequest) -> dict:
+    out: dict = {}
+    if "error" in value:
+        import capo_lambda.types.error_object
+
+        out["Error"] = capo_lambda.types.error_object.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackFailureRequest:
+    out: SendDurableExecutionCallbackFailureRequest = {}  # type: ignore[typeddict-item]
+    if "Error" in data:
+        import capo_lambda.types.error_object
+
+        out["error"] = capo_lambda.types.error_object.deserialize_json(data["Error"])
+    return out

capo_lambda/types/send_durable_execution_callback_failure_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackFailureResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class SendDurableExecutionCallbackFailureResponse(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackFailureResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackFailureResponse:
+    out: SendDurableExecutionCallbackFailureResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/send_durable_execution_callback_heartbeat_request.py

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

capo_lambda/types/send_durable_execution_callback_heartbeat_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackHeartbeatResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class SendDurableExecutionCallbackHeartbeatResponse(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackHeartbeatResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackHeartbeatResponse:
+    out: SendDurableExecutionCallbackHeartbeatResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/send_durable_execution_callback_success_request.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackSuccessRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.binary_operation_payload
+    import capo_lambda.types.callback_id
+
+
+class SendDurableExecutionCallbackSuccessRequest(TypedDict, closed=True):
+    callback_id: "capo_lambda.types.callback_id.CallbackId"
+    """<p>The unique identifier for the callback operation.</p>"""
+    result: NotRequired[
+        "capo_lambda.types.binary_operation_payload.BinaryOperationPayload"
+    ]
+    """<p>The result data from the successful callback operation. Maximum size is 256 KB.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackSuccessRequest) -> dict:
+    out: dict = {}
+    if "result" in value:
+        import capo_lambda.types.binary_operation_payload
+
+        out["Result"] = capo_lambda.types.binary_operation_payload.serialize_json(
+            value["result"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackSuccessRequest:
+    out: SendDurableExecutionCallbackSuccessRequest = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        import capo_lambda.types.binary_operation_payload
+
+        out["result"] = capo_lambda.types.binary_operation_payload.deserialize_json(
+            data["Result"]
+        )
+    return out

capo_lambda/types/send_durable_execution_callback_success_response.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackSuccessResponse``."""
+
+from typing_extensions import TypedDict
+
+
+class SendDurableExecutionCallbackSuccessResponse(TypedDict, closed=True):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackSuccessResponse) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackSuccessResponse:
+    out: SendDurableExecutionCallbackSuccessResponse = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/sensitive_string.py

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

capo_lambda/types/signing_profile_version_arns.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SigningProfileVersionArns``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.arn
+
+SigningProfileVersionArns: TypeAlias = list["capo_lambda.types.arn.Arn"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SigningProfileVersionArns) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> SigningProfileVersionArns:
+    return list(data)

capo_lambda/types/snap_start.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SnapStart``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.snap_start_apply_on
+
+
+class SnapStart(TypedDict, closed=True):
+    apply_on: NotRequired["capo_lambda.types.snap_start_apply_on.SnapStartApplyOn"]
+    """<p>Set to <code>PublishedVersions</code> to create a snapshot of the initialized execution environment when you publish a function version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SnapStart) -> dict:
+    out: dict = {}
+    if "apply_on" in value:
+        import capo_lambda.types.snap_start_apply_on
+
+        out["ApplyOn"] = capo_lambda.types.snap_start_apply_on.serialize_json(
+            value["apply_on"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SnapStart:
+    out: SnapStart = {}  # type: ignore[typeddict-item]
+    if "ApplyOn" in data:
+        import capo_lambda.types.snap_start_apply_on
+
+        out["apply_on"] = capo_lambda.types.snap_start_apply_on.deserialize_json(
+            data["ApplyOn"]
+        )
+    return out

capo_lambda/types/snap_start_apply_on.py

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

capo_lambda/types/snap_start_optimization_status.py

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

capo_lambda/types/snap_start_response.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SnapStartResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.snap_start_apply_on
+    import capo_lambda.types.snap_start_optimization_status
+
+
+class SnapStartResponse(TypedDict, closed=True):
+    apply_on: NotRequired["capo_lambda.types.snap_start_apply_on.SnapStartApplyOn"]
+    """<p>When set to <code>PublishedVersions</code>, Lambda creates a snapshot of the execution environment when you publish a function version.</p>"""
+    optimization_status: NotRequired[
+        "capo_lambda.types.snap_start_optimization_status.SnapStartOptimizationStatus"
+    ]
+    r"""<p>When you provide a <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html#versioning-versions-using\">qualified Amazon Resource Name (ARN)</a>, this response element indicates whether SnapStart is activated for the specified function version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SnapStartResponse) -> dict:
+    out: dict = {}
+    if "apply_on" in value:
+        import capo_lambda.types.snap_start_apply_on
+
+        out["ApplyOn"] = capo_lambda.types.snap_start_apply_on.serialize_json(
+            value["apply_on"]
+        )
+    if "optimization_status" in value:
+        import capo_lambda.types.snap_start_optimization_status
+
+        out["OptimizationStatus"] = (
+            capo_lambda.types.snap_start_optimization_status.serialize_json(
+                value["optimization_status"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SnapStartResponse:
+    out: SnapStartResponse = {}  # type: ignore[typeddict-item]
+    if "ApplyOn" in data:
+        import capo_lambda.types.snap_start_apply_on
+
+        out["apply_on"] = capo_lambda.types.snap_start_apply_on.deserialize_json(
+            data["ApplyOn"]
+        )
+    if "OptimizationStatus" in data:
+        import capo_lambda.types.snap_start_optimization_status
+
+        out["optimization_status"] = (
+            capo_lambda.types.snap_start_optimization_status.deserialize_json(
+                data["OptimizationStatus"]
+            )
+        )
+    return out

capo_lambda/types/source_access_configuration.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SourceAccessConfiguration``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.source_access_type
+    import capo_lambda.types.uri
+
+
+class SourceAccessConfiguration(TypedDict, closed=True):
+    type: NotRequired["capo_lambda.types.source_access_type.SourceAccessType"]
+    r"""<p>The type of authentication protocol, VPC components, or virtual host for your event source. For example: <code>\"Type\":\"SASL_SCRAM_512_AUTH\"</code>.</p> <ul> <li> <p> <code>BASIC_AUTH</code> – (Amazon MQ) The Secrets Manager secret that stores your broker credentials.</p> </li> <li> <p> <code>BASIC_AUTH</code> – (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL/PLAIN authentication of your Apache Kafka brokers.</p> </li> <li> <p> <code>VPC_SUBNET</code> – (Self-managed Apache Kafka) The subnets associated with your VPC. Lambda connects to these subnets to fetch data from your self-managed Apache Kafka cluster.</p> </li> <li> <p> <code>VPC_SECURITY_GROUP</code> – (Self-managed Apache Kafka) The VPC security group used to manage access to your self-managed Apache Kafka brokers.</p> </li> <li> <p> <code>SASL_SCRAM_256_AUTH</code> – (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL SCRAM-256 authentication of your self-managed Apache Kafka brokers.</p> </li> <li> <p> <code>SASL_SCRAM_512_AUTH</code> – (Amazon MSK, Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL SCRAM-512 authentication of your self-managed Apache Kafka brokers.</p> </li> <li> <p> <code>VIRTUAL_HOST</code> –- (RabbitMQ) The name of the virtual host in your RabbitMQ broker. Lambda uses this RabbitMQ host as the event source. This property cannot be specified in an UpdateEventSourceMapping API call.</p> </li> <li> <p> <code>CLIENT_CERTIFICATE_TLS_AUTH</code> – (Amazon MSK, self-managed Apache Kafka) The Secrets Manager ARN of your secret key containing the certificate chain (X.509 PEM), private key (PKCS#8 PEM), and private key password (optional) used for mutual TLS authentication of your MSK/Apache Kafka brokers.</p> </li> <li> <p> <code>SERVER_ROOT_CA_CERTIFICATE</code> – (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key containing the root CA certificate (X.509 PEM) used for TLS encryption of your Apache Kafka brokers. </p> </li> </ul>"""
+    uri: NotRequired["capo_lambda.types.uri.URI"]
+    r"""<p>The value for your chosen configuration in <code>Type</code>. For example: <code>\"URI\": \"arn:aws:secretsmanager:us-east-1:01234567890:secret:MyBrokerSecretName\"</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SourceAccessConfiguration) -> dict:
+    out: dict = {}
+    if "type" in value:
+        import capo_lambda.types.source_access_type
+
+        out["Type"] = capo_lambda.types.source_access_type.serialize_json(value["type"])
+    if "uri" in value:
+        out["URI"] = value["uri"]
+    return out
+
+
+def deserialize_json(data: dict) -> SourceAccessConfiguration:
+    out: SourceAccessConfiguration = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        import capo_lambda.types.source_access_type
+
+        out["type"] = capo_lambda.types.source_access_type.deserialize_json(
+            data["Type"]
+        )
+    if "URI" in data:
+        out["uri"] = data["URI"]
+    return out

capo_lambda/types/source_access_configurations.py

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

capo_lambda/types/source_access_type.py

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

capo_lambda/types/source_owner.py

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

capo_lambda/types/stack_trace_entries.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StackTraceEntries``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda.types.stack_trace_entry
+
+StackTraceEntries: TypeAlias = list[
+    "capo_lambda.types.stack_trace_entry.StackTraceEntry"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StackTraceEntries) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> StackTraceEntries:
+    return list(data)

capo_lambda/types/stack_trace_entry.py

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

capo_lambda/types/state.py

@@ -0,0 +1,23 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#State``."""
+
+from typing import Literal, TypeAlias, cast
+
+State: TypeAlias = Literal[
+    "Pending",
+    "Active",
+    "Inactive",
+    "Failed",
+    "Deactivating",
+    "Deactivated",
+    "ActiveNonInvocable",
+    "Deleting",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: State) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> State:
+    return cast(State, data)

capo_lambda/types/state_reason.py

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

capo_lambda/types/state_reason_code.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StateReasonCode``."""
+
+from typing import Literal, TypeAlias, cast
+
+StateReasonCode: TypeAlias = Literal[
+    "Idle",
+    "Creating",
+    "Restoring",
+    "EniLimitExceeded",
+    "InsufficientRolePermissions",
+    "InvalidConfiguration",
+    "InternalError",
+    "SubnetOutOfIPAddresses",
+    "InvalidSubnet",
+    "InvalidSecurityGroup",
+    "ImageDeleted",
+    "ImageAccessDenied",
+    "InvalidImage",
+    "KMSKeyAccessDenied",
+    "KMSKeyNotFound",
+    "InvalidStateKMSKey",
+    "DisabledKMSKey",
+    "EFSIOError",
+    "EFSMountConnectivityError",
+    "EFSMountFailure",
+    "EFSMountTimeout",
+    "InvalidRuntime",
+    "InvalidZipFileException",
+    "FunctionError",
+    "DrainingDurableExecutions",
+    "VcpuLimitExceeded",
+    "CapacityProviderScalingLimitExceeded",
+    "InsufficientCapacity",
+    "EC2RequestLimitExceeded",
+    "FunctionError.InitTimeout",
+    "FunctionError.RuntimeInitError",
+    "FunctionError.ExtensionInitError",
+    "FunctionError.InvalidEntryPoint",
+    "FunctionError.InvalidWorkingDirectory",
+    "FunctionError.PermissionDenied",
+    "FunctionError.TooManyExtensions",
+    "FunctionError.InitResourceExhausted",
+    "DisallowedByVpcEncryptionControl",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StateReasonCode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> StateReasonCode:
+    return cast(StateReasonCode, data)

capo_lambda/types/statement_id.py

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