capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/put_provisioned_concurrency_config_response.py

@@ -0,0 +1,94 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutProvisionedConcurrencyConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.non_negative_integer
+    import capo_lambda.types.positive_integer
+    import capo_lambda.types.provisioned_concurrency_status_enum
+    import capo_lambda.types.string
+    import capo_lambda.types.timestamp
+
+
+class PutProvisionedConcurrencyConfigResponse(TypedDict, closed=True):
+    requested_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.positive_integer.PositiveInteger"
+    ]
+    """<p>The amount of provisioned concurrency requested.</p>"""
+    available_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency available.</p>"""
+    allocated_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency allocated. When a weighted alias is used during linear and canary deployments, this value fluctuates depending on the amount of concurrency that is provisioned for the function versions.</p>"""
+    status: NotRequired[
+        "capo_lambda.types.provisioned_concurrency_status_enum.ProvisionedConcurrencyStatusEnum"
+    ]
+    """<p>The status of the allocation process.</p>"""
+    status_reason: NotRequired["capo_lambda.types.string.String"]
+    """<p>For failed allocations, the reason that provisioned concurrency could not be allocated.</p>"""
+    last_modified: NotRequired["capo_lambda.types.timestamp.Timestamp"]
+    r"""<p>The date and time that a user last updated the configuration, in <a href=\"https://www.iso.org/iso-8601-date-and-time-format.html\">ISO 8601 format</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutProvisionedConcurrencyConfigResponse) -> dict:
+    out: dict = {}
+    if "requested_provisioned_concurrent_executions" in value:
+        out["RequestedProvisionedConcurrentExecutions"] = value[
+            "requested_provisioned_concurrent_executions"
+        ]
+    if "available_provisioned_concurrent_executions" in value:
+        out["AvailableProvisionedConcurrentExecutions"] = value[
+            "available_provisioned_concurrent_executions"
+        ]
+    if "allocated_provisioned_concurrent_executions" in value:
+        out["AllocatedProvisionedConcurrentExecutions"] = value[
+            "allocated_provisioned_concurrent_executions"
+        ]
+    if "status" in value:
+        import capo_lambda.types.provisioned_concurrency_status_enum
+
+        out["Status"] = (
+            capo_lambda.types.provisioned_concurrency_status_enum.serialize_json(
+                value["status"]
+            )
+        )
+    if "status_reason" in value:
+        out["StatusReason"] = value["status_reason"]
+    if "last_modified" in value:
+        out["LastModified"] = value["last_modified"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutProvisionedConcurrencyConfigResponse:
+    out: PutProvisionedConcurrencyConfigResponse = {}  # type: ignore[typeddict-item]
+    if "RequestedProvisionedConcurrentExecutions" in data:
+        out["requested_provisioned_concurrent_executions"] = data[
+            "RequestedProvisionedConcurrentExecutions"
+        ]
+    if "AvailableProvisionedConcurrentExecutions" in data:
+        out["available_provisioned_concurrent_executions"] = data[
+            "AvailableProvisionedConcurrentExecutions"
+        ]
+    if "AllocatedProvisionedConcurrentExecutions" in data:
+        out["allocated_provisioned_concurrent_executions"] = data[
+            "AllocatedProvisionedConcurrentExecutions"
+        ]
+    if "Status" in data:
+        import capo_lambda.types.provisioned_concurrency_status_enum
+
+        out["status"] = (
+            capo_lambda.types.provisioned_concurrency_status_enum.deserialize_json(
+                data["Status"]
+            )
+        )
+    if "StatusReason" in data:
+        out["status_reason"] = data["StatusReason"]
+    if "LastModified" in data:
+        out["last_modified"] = data["LastModified"]
+    return out

capo_lambda/types/put_runtime_management_config_request.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutRuntimeManagementConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+    import capo_lambda.types.runtime_version_arn
+    import capo_lambda.types.update_runtime_on
+
+
+class PutRuntimeManagementConfigRequest(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>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version of the function. This can be <code>$LATEST</code> or a published version number. If no value is specified, the configuration for the <code>$LATEST</code> version is returned.</p>"""
+    update_runtime_on: "capo_lambda.types.update_runtime_on.UpdateRuntimeOn"
+    r"""<p>Specify the runtime update mode.</p> <ul> <li> <p> <b>Auto (default)</b> - Automatically update to the most recent and secure runtime version using a <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html#runtime-management-two-phase\">Two-phase runtime version rollout</a>. This is the best choice for most customers to ensure they always benefit from runtime updates.</p> </li> <li> <p> <b>Function update</b> - Lambda updates the runtime of your function to the most recent and secure runtime version when you update your function. This approach synchronizes runtime updates with function deployments, giving you control over when runtime updates are applied and allowing you to detect and mitigate rare runtime update incompatibilities early. When using this setting, you need to regularly update your functions to keep their runtime up-to-date.</p> </li> <li> <p> <b>Manual</b> - You specify a runtime version in your function configuration. The function will use this runtime version indefinitely. In the rare case where a new runtime version is incompatible with an existing function, this allows you to roll back your function to an earlier runtime version. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/runtimes-update.html#runtime-management-rollback\">Roll back a runtime version</a>.</p> </li> </ul>"""
+    runtime_version_arn: NotRequired[
+        "capo_lambda.types.runtime_version_arn.RuntimeVersionArn"
+    ]
+    """<p>The ARN of the runtime version you want the function to use.</p> <note> <p>This is only required if you're using the <b>Manual</b> runtime update mode.</p> </note>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutRuntimeManagementConfigRequest) -> dict:
+    out: dict = {}
+    import capo_lambda.types.update_runtime_on
+
+    out["UpdateRuntimeOn"] = capo_lambda.types.update_runtime_on.serialize_json(
+        value["update_runtime_on"]
+    )
+    if "runtime_version_arn" in value:
+        out["RuntimeVersionArn"] = value["runtime_version_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutRuntimeManagementConfigRequest:
+    out: PutRuntimeManagementConfigRequest = {}  # type: ignore[typeddict-item]
+    if "UpdateRuntimeOn" in data:
+        import capo_lambda.types.update_runtime_on
+
+        out["update_runtime_on"] = capo_lambda.types.update_runtime_on.deserialize_json(
+            data["UpdateRuntimeOn"]
+        )
+    else:
+        raise DeserializationError(
+            "PutRuntimeManagementConfigRequest.update_runtime_on required"
+        )
+    if "RuntimeVersionArn" in data:
+        out["runtime_version_arn"] = data["RuntimeVersionArn"]
+    return out

capo_lambda/types/put_runtime_management_config_response.py

@@ -0,0 +1,60 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutRuntimeManagementConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_arn
+    import capo_lambda.types.runtime_version_arn
+    import capo_lambda.types.update_runtime_on
+
+
+class PutRuntimeManagementConfigResponse(TypedDict, closed=True):
+    update_runtime_on: "capo_lambda.types.update_runtime_on.UpdateRuntimeOn"
+    """<p>The runtime update mode.</p>"""
+    function_arn: "capo_lambda.types.function_arn.FunctionArn"
+    """<p>The ARN of the function</p>"""
+    runtime_version_arn: NotRequired[
+        "capo_lambda.types.runtime_version_arn.RuntimeVersionArn"
+    ]
+    """<p>The ARN of the runtime the function is configured to use. If the runtime update mode is <b>manual</b>, the ARN is returned, otherwise <code>null</code> is returned.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutRuntimeManagementConfigResponse) -> dict:
+    out: dict = {}
+    import capo_lambda.types.update_runtime_on
+
+    out["UpdateRuntimeOn"] = capo_lambda.types.update_runtime_on.serialize_json(
+        value["update_runtime_on"]
+    )
+    out["FunctionArn"] = value["function_arn"]
+    if "runtime_version_arn" in value:
+        out["RuntimeVersionArn"] = value["runtime_version_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutRuntimeManagementConfigResponse:
+    out: PutRuntimeManagementConfigResponse = {}  # type: ignore[typeddict-item]
+    if "UpdateRuntimeOn" in data:
+        import capo_lambda.types.update_runtime_on
+
+        out["update_runtime_on"] = capo_lambda.types.update_runtime_on.deserialize_json(
+            data["UpdateRuntimeOn"]
+        )
+    else:
+        raise DeserializationError(
+            "PutRuntimeManagementConfigResponse.update_runtime_on required"
+        )
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError(
+            "PutRuntimeManagementConfigResponse.function_arn required"
+        )
+    if "RuntimeVersionArn" in data:
+        out["runtime_version_arn"] = data["RuntimeVersionArn"]
+    return out

capo_lambda/types/qualifier.py

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

capo_lambda/types/queue.py

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

capo_lambda/types/queues.py

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

capo_lambda/types/recursive_loop.py

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

capo_lambda/types/remove_layer_version_permission_request.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RemoveLayerVersionPermissionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.layer_name
+    import capo_lambda.types.layer_version_number
+    import capo_lambda.types.statement_id
+    import capo_lambda.types.string
+
+
+class RemoveLayerVersionPermissionRequest(TypedDict, closed=True):
+    layer_name: "capo_lambda.types.layer_name.LayerName"
+    """<p>The name or Amazon Resource Name (ARN) of the layer.</p>"""
+    version_number: "capo_lambda.types.layer_version_number.LayerVersionNumber"
+    """<p>The version number.</p>"""
+    statement_id: "capo_lambda.types.statement_id.StatementId"
+    """<p>The identifier that was specified when the statement was added.</p>"""
+    revision_id: NotRequired["capo_lambda.types.string.String"]
+    """<p>Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a policy that has changed since you last read it.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RemoveLayerVersionPermissionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> RemoveLayerVersionPermissionRequest:
+    out: RemoveLayerVersionPermissionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/remove_permission_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RemovePermissionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.namespaced_statement_id
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+    import capo_lambda.types.string
+
+
+class RemovePermissionRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    r"""<p>The name or ARN of the Lambda function, version, or alias.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code> (name-only), <code>my-function:v1</code> (with alias).</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>You can append a version number or alias to any of the formats. 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>"""
+    statement_id: "capo_lambda.types.namespaced_statement_id.NamespacedStatementId"
+    """<p>Statement ID of the permission to remove.</p>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version or alias to remove permissions from a published version of the function.</p>"""
+    revision_id: NotRequired["capo_lambda.types.string.String"]
+    """<p>Update the policy only if the revision ID matches the ID that's specified. Use this option to avoid modifying a policy that has changed since you last read it.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RemovePermissionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> RemovePermissionRequest:
+    out: RemovePermissionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/replay_children.py

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

capo_lambda/types/reserved_concurrent_executions.py

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

capo_lambda/types/resource_arn.py

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

capo_lambda/types/response_streaming_invocation_type.py

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

capo_lambda/types/retention_period_in_days.py

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

capo_lambda/types/retry_details.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RetryDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.attempt_count
+    import capo_lambda.types.duration_seconds
+
+
+class RetryDetails(TypedDict, closed=True):
+    current_attempt: "capo_lambda.types.attempt_count.AttemptCount"
+    """<p>The current attempt number for this operation.</p>"""
+    next_attempt_delay_seconds: NotRequired[
+        "capo_lambda.types.duration_seconds.DurationSeconds"
+    ]
+    """<p>The delay before the next retry attempt, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RetryDetails) -> dict:
+    out: dict = {}
+    out["CurrentAttempt"] = value.get("current_attempt", 0)
+    if "next_attempt_delay_seconds" in value:
+        out["NextAttemptDelaySeconds"] = value["next_attempt_delay_seconds"]
+    return out
+
+
+def deserialize_json(data: dict) -> RetryDetails:
+    out: RetryDetails = {}  # type: ignore[typeddict-item]
+    if "CurrentAttempt" in data:
+        out["current_attempt"] = data["CurrentAttempt"]
+    else:
+        out["current_attempt"] = 0
+    if "NextAttemptDelaySeconds" in data:
+        out["next_attempt_delay_seconds"] = data["NextAttemptDelaySeconds"]
+    return out

capo_lambda/types/reverse_order.py

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

capo_lambda/types/role_arn.py

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

capo_lambda/types/runtime.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Runtime``."""
+
+from typing import Literal, TypeAlias, cast
+
+Runtime: TypeAlias = Literal[
+    "nodejs",
+    "nodejs4.3",
+    "nodejs6.10",
+    "nodejs8.10",
+    "nodejs10.x",
+    "nodejs12.x",
+    "nodejs14.x",
+    "nodejs16.x",
+    "java8",
+    "java8.al2",
+    "java11",
+    "python2.7",
+    "python3.6",
+    "python3.7",
+    "python3.8",
+    "python3.9",
+    "dotnetcore1.0",
+    "dotnetcore2.0",
+    "dotnetcore2.1",
+    "dotnetcore3.1",
+    "dotnet6",
+    "dotnet8",
+    "nodejs4.3-edge",
+    "go1.x",
+    "ruby2.5",
+    "ruby2.7",
+    "provided",
+    "provided.al2",
+    "nodejs18.x",
+    "python3.10",
+    "java17",
+    "ruby3.2",
+    "ruby3.3",
+    "ruby3.4",
+    "python3.11",
+    "nodejs20.x",
+    "provided.al2023",
+    "python3.12",
+    "java21",
+    "python3.13",
+    "nodejs22.x",
+    "nodejs24.x",
+    "python3.14",
+    "java25",
+    "dotnet10",
+    "ruby4.0",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Runtime) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Runtime:
+    return cast(Runtime, data)

capo_lambda/types/runtime_version_arn.py

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

capo_lambda/types/runtime_version_config.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RuntimeVersionConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.runtime_version_arn
+    import capo_lambda.types.runtime_version_error
+
+
+class RuntimeVersionConfig(TypedDict, closed=True):
+    runtime_version_arn: NotRequired[
+        "capo_lambda.types.runtime_version_arn.RuntimeVersionArn"
+    ]
+    """<p>The ARN of the runtime version you want the function to use.</p>"""
+    error: NotRequired["capo_lambda.types.runtime_version_error.RuntimeVersionError"]
+    """<p>Error response when Lambda is unable to retrieve the runtime version for a function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RuntimeVersionConfig) -> dict:
+    out: dict = {}
+    if "runtime_version_arn" in value:
+        out["RuntimeVersionArn"] = value["runtime_version_arn"]
+    if "error" in value:
+        import capo_lambda.types.runtime_version_error
+
+        out["Error"] = capo_lambda.types.runtime_version_error.serialize_json(
+            value["error"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> RuntimeVersionConfig:
+    out: RuntimeVersionConfig = {}  # type: ignore[typeddict-item]
+    if "RuntimeVersionArn" in data:
+        out["runtime_version_arn"] = data["RuntimeVersionArn"]
+    if "Error" in data:
+        import capo_lambda.types.runtime_version_error
+
+        out["error"] = capo_lambda.types.runtime_version_error.deserialize_json(
+            data["Error"]
+        )
+    return out

capo_lambda/types/runtime_version_error.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RuntimeVersionError``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.sensitive_string
+    import capo_lambda.types.string
+
+
+class RuntimeVersionError(TypedDict, closed=True):
+    error_code: NotRequired["capo_lambda.types.string.String"]
+    """<p>The error code.</p>"""
+    message: NotRequired["capo_lambda.types.sensitive_string.SensitiveString"]
+    """<p>The error message.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RuntimeVersionError) -> dict:
+    out: dict = {}
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> RuntimeVersionError:
+    out: RuntimeVersionError = {}  # type: ignore[typeddict-item]
+    if "ErrorCode" in data:
+        out["error_code"] = data["ErrorCode"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out

capo_lambda/types/s3_bucket.py

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

capo_lambda/types/s3_key.py

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

capo_lambda/types/s3_object_version.py

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

capo_lambda/types/scaling_config.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ScalingConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.maximum_concurrency
+
+
+class ScalingConfig(TypedDict, closed=True):
+    maximum_concurrency: NotRequired[
+        "capo_lambda.types.maximum_concurrency.MaximumConcurrency"
+    ]
+    """<p>Limits the number of concurrent instances that the Amazon SQS event source can invoke.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ScalingConfig) -> dict:
+    out: dict = {}
+    if "maximum_concurrency" in value:
+        out["MaximumConcurrency"] = value["maximum_concurrency"]
+    return out
+
+
+def deserialize_json(data: dict) -> ScalingConfig:
+    out: ScalingConfig = {}  # type: ignore[typeddict-item]
+    if "MaximumConcurrency" in data:
+        out["maximum_concurrency"] = data["MaximumConcurrency"]
+    return out

capo_lambda/types/schema_registry_event_record_format.py

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