aws-sdk-lambda 0.4.0__py3-none-any.whl

aws_sdk_lambda/types/put_function_concurrency_request.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionConcurrencyRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_name
+    import aws_sdk_lambda.types.reserved_concurrent_executions
+
+
+class PutFunctionConcurrencyRequest(TypedDict):
+    function_name: "aws_sdk_lambda.types.function_name.FunctionName"
+    """<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>"""
+    reserved_concurrent_executions: "aws_sdk_lambda.types.reserved_concurrent_executions.ReservedConcurrentExecutions"
+    """<p>The number of simultaneous executions to reserve for the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionConcurrencyRequest) -> dict:
+    out: dict = {}
+    out["ReservedConcurrentExecutions"] = value["reserved_concurrent_executions"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionConcurrencyRequest:
+    out: PutFunctionConcurrencyRequest = {}  # type: ignore[typeddict-item]
+    if "ReservedConcurrentExecutions" in data:
+        out["reserved_concurrent_executions"] = data["ReservedConcurrentExecutions"]
+    else:
+        raise DeserializationError(
+            "PutFunctionConcurrencyRequest.reserved_concurrent_executions required"
+        )
+    return out

aws_sdk_lambda/types/put_function_event_invoke_config_request.py

@@ -0,0 +1,70 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionEventInvokeConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.destination_config
+    import aws_sdk_lambda.types.maximum_event_age_in_seconds
+    import aws_sdk_lambda.types.maximum_retry_attempts
+    import aws_sdk_lambda.types.namespaced_function_name
+    import aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier
+
+
+class PutFunctionEventInvokeConfigRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    )
+    """<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>"""
+    qualifier: NotRequired[
+        "aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>A version number or alias name.</p>"""
+    maximum_retry_attempts: NotRequired[
+        "aws_sdk_lambda.types.maximum_retry_attempts.MaximumRetryAttempts"
+    ]
+    """<p>The maximum number of times to retry when the function returns an error.</p>"""
+    maximum_event_age_in_seconds: NotRequired[
+        "aws_sdk_lambda.types.maximum_event_age_in_seconds.MaximumEventAgeInSeconds"
+    ]
+    """<p>The maximum age of a request that Lambda sends to a function for processing.</p>"""
+    destination_config: NotRequired[
+        "aws_sdk_lambda.types.destination_config.DestinationConfig"
+    ]
+    """<p>A destination for events after they have been sent to a function for processing.</p> <p class=\"title\"> <b>Destinations</b> </p> <ul> <li> <p> <b>Function</b> - The Amazon Resource Name (ARN) of a Lambda function.</p> </li> <li> <p> <b>Queue</b> - The ARN of a standard SQS queue.</p> </li> <li> <p> <b>Bucket</b> - The ARN of an Amazon S3 bucket.</p> </li> <li> <p> <b>Topic</b> - The ARN of a standard SNS topic.</p> </li> <li> <p> <b>Event Bus</b> - The ARN of an Amazon EventBridge event bus.</p> </li> </ul> <note> <p>S3 buckets are supported only for on-failure destinations. To retain records of successful invocations, use another destination type.</p> </note>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionEventInvokeConfigRequest) -> dict:
+    out: dict = {}
+    if "maximum_retry_attempts" in value:
+        out["MaximumRetryAttempts"] = value["maximum_retry_attempts"]
+    if "maximum_event_age_in_seconds" in value:
+        out["MaximumEventAgeInSeconds"] = value["maximum_event_age_in_seconds"]
+    if "destination_config" in value:
+        import aws_sdk_lambda.types.destination_config
+
+        out["DestinationConfig"] = (
+            aws_sdk_lambda.types.destination_config.serialize_json(
+                value["destination_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionEventInvokeConfigRequest:
+    out: PutFunctionEventInvokeConfigRequest = {}  # type: ignore[typeddict-item]
+    if "MaximumRetryAttempts" in data:
+        out["maximum_retry_attempts"] = data["MaximumRetryAttempts"]
+    if "MaximumEventAgeInSeconds" in data:
+        out["maximum_event_age_in_seconds"] = data["MaximumEventAgeInSeconds"]
+    if "DestinationConfig" in data:
+        import aws_sdk_lambda.types.destination_config
+
+        out["destination_config"] = (
+            aws_sdk_lambda.types.destination_config.deserialize_json(
+                data["DestinationConfig"]
+            )
+        )
+    return out

aws_sdk_lambda/types/put_function_recursion_config_request.py

@@ -0,0 +1,44 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionRecursionConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.recursive_loop
+    import aws_sdk_lambda.types.unqualified_function_name
+
+
+class PutFunctionRecursionConfigRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.unqualified_function_name.UnqualifiedFunctionName"
+    )
+    """<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>"""
+    recursive_loop: "aws_sdk_lambda.types.recursive_loop.RecursiveLoop"
+    """<p>If you set your function's recursive loop detection configuration to <code>Allow</code>, Lambda doesn't take any action when it detects your function being invoked as part of a recursive loop. We recommend that you only use this setting if your design intentionally uses a Lambda function to write data back to the same Amazon Web Services resource that invokes it.</p> <p>If you set your function's recursive loop detection configuration to <code>Terminate</code>, Lambda stops your function being invoked and notifies you when it detects your function being invoked as part of a recursive loop.</p> <p>By default, Lambda sets your function's configuration to <code>Terminate</code>.</p> <important> <p>If your design intentionally uses a Lambda function to write data back to the same Amazon Web Services resource that invokes the function, then use caution and implement suitable guard rails to prevent unexpected charges being billed to your Amazon Web Services account. To learn more about best practices for using recursive invocation patterns, see <a href=\"https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/recursive-runaway\">Recursive patterns that cause run-away Lambda functions</a> in Serverless Land.</p> </important>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionRecursionConfigRequest) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.recursive_loop
+
+    out["RecursiveLoop"] = aws_sdk_lambda.types.recursive_loop.serialize_json(
+        value["recursive_loop"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionRecursionConfigRequest:
+    out: PutFunctionRecursionConfigRequest = {}  # type: ignore[typeddict-item]
+    if "RecursiveLoop" in data:
+        import aws_sdk_lambda.types.recursive_loop
+
+        out["recursive_loop"] = aws_sdk_lambda.types.recursive_loop.deserialize_json(
+            data["RecursiveLoop"]
+        )
+    else:
+        raise DeserializationError(
+            "PutFunctionRecursionConfigRequest.recursive_loop required"
+        )
+    return out

aws_sdk_lambda/types/put_function_recursion_config_response.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionRecursionConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.recursive_loop
+
+
+class PutFunctionRecursionConfigResponse(TypedDict):
+    recursive_loop: NotRequired["aws_sdk_lambda.types.recursive_loop.RecursiveLoop"]
+    """<p>The status of your function's recursive loop detection configuration.</p> <p>When this value is set to <code>Allow</code>and Lambda detects your function being invoked as part of a recursive loop, it doesn't take any action.</p> <p>When this value is set to <code>Terminate</code> and Lambda detects your function being invoked as part of a recursive loop, it stops your function being invoked and notifies you. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionRecursionConfigResponse) -> dict:
+    out: dict = {}
+    if "recursive_loop" in value:
+        import aws_sdk_lambda.types.recursive_loop
+
+        out["RecursiveLoop"] = aws_sdk_lambda.types.recursive_loop.serialize_json(
+            value["recursive_loop"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionRecursionConfigResponse:
+    out: PutFunctionRecursionConfigResponse = {}  # type: ignore[typeddict-item]
+    if "RecursiveLoop" in data:
+        import aws_sdk_lambda.types.recursive_loop
+
+        out["recursive_loop"] = aws_sdk_lambda.types.recursive_loop.deserialize_json(
+            data["RecursiveLoop"]
+        )
+    return out

aws_sdk_lambda/types/put_function_scaling_config_request.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionScalingConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_scaling_config
+    import aws_sdk_lambda.types.published_function_qualifier
+    import aws_sdk_lambda.types.unqualified_function_name
+
+
+class PutFunctionScalingConfigRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.unqualified_function_name.UnqualifiedFunctionName"
+    )
+    """<p>The name or ARN of the Lambda function.</p>"""
+    qualifier: (
+        "aws_sdk_lambda.types.published_function_qualifier.PublishedFunctionQualifier"
+    )
+    """<p>Specify a version or alias to set the scaling configuration for a published version of the function.</p>"""
+    function_scaling_config: NotRequired[
+        "aws_sdk_lambda.types.function_scaling_config.FunctionScalingConfig"
+    ]
+    """<p>The scaling configuration to apply to the function, including minimum and maximum execution environment limits.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionScalingConfigRequest) -> dict:
+    out: dict = {}
+    if "function_scaling_config" in value:
+        import aws_sdk_lambda.types.function_scaling_config
+
+        out["FunctionScalingConfig"] = (
+            aws_sdk_lambda.types.function_scaling_config.serialize_json(
+                value["function_scaling_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionScalingConfigRequest:
+    out: PutFunctionScalingConfigRequest = {}  # type: ignore[typeddict-item]
+    if "FunctionScalingConfig" in data:
+        import aws_sdk_lambda.types.function_scaling_config
+
+        out["function_scaling_config"] = (
+            aws_sdk_lambda.types.function_scaling_config.deserialize_json(
+                data["FunctionScalingConfig"]
+            )
+        )
+    return out

aws_sdk_lambda/types/put_function_scaling_config_response.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionScalingConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.state
+
+
+class PutFunctionScalingConfigResponse(TypedDict):
+    function_state: NotRequired["aws_sdk_lambda.types.state.State"]
+    """<p>The current state of the function after applying the scaling configuration.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionScalingConfigResponse) -> dict:
+    out: dict = {}
+    if "function_state" in value:
+        import aws_sdk_lambda.types.state
+
+        out["FunctionState"] = aws_sdk_lambda.types.state.serialize_json(
+            value["function_state"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionScalingConfigResponse:
+    out: PutFunctionScalingConfigResponse = {}  # type: ignore[typeddict-item]
+    if "FunctionState" in data:
+        import aws_sdk_lambda.types.state
+
+        out["function_state"] = aws_sdk_lambda.types.state.deserialize_json(
+            data["FunctionState"]
+        )
+    return out

aws_sdk_lambda/types/put_provisioned_concurrency_config_request.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutProvisionedConcurrencyConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_name
+    import aws_sdk_lambda.types.positive_integer
+    import aws_sdk_lambda.types.qualifier
+
+
+class PutProvisionedConcurrencyConfigRequest(TypedDict):
+    function_name: "aws_sdk_lambda.types.function_name.FunctionName"
+    """<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: "aws_sdk_lambda.types.qualifier.Qualifier"
+    """<p>The version number or alias name.</p>"""
+    provisioned_concurrent_executions: (
+        "aws_sdk_lambda.types.positive_integer.PositiveInteger"
+    )
+    """<p>The amount of provisioned concurrency to allocate for the version or alias.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutProvisionedConcurrencyConfigRequest) -> dict:
+    out: dict = {}
+    out["ProvisionedConcurrentExecutions"] = value["provisioned_concurrent_executions"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutProvisionedConcurrencyConfigRequest:
+    out: PutProvisionedConcurrencyConfigRequest = {}  # type: ignore[typeddict-item]
+    if "ProvisionedConcurrentExecutions" in data:
+        out["provisioned_concurrent_executions"] = data[
+            "ProvisionedConcurrentExecutions"
+        ]
+    else:
+        raise DeserializationError(
+            "PutProvisionedConcurrencyConfigRequest.provisioned_concurrent_executions required"
+        )
+    return out

aws_sdk_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, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.non_negative_integer
+    import aws_sdk_lambda.types.positive_integer
+    import aws_sdk_lambda.types.provisioned_concurrency_status_enum
+    import aws_sdk_lambda.types.string
+    import aws_sdk_lambda.types.timestamp
+
+
+class PutProvisionedConcurrencyConfigResponse(TypedDict):
+    requested_provisioned_concurrent_executions: NotRequired[
+        "aws_sdk_lambda.types.positive_integer.PositiveInteger"
+    ]
+    """<p>The amount of provisioned concurrency requested.</p>"""
+    available_provisioned_concurrent_executions: NotRequired[
+        "aws_sdk_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency available.</p>"""
+    allocated_provisioned_concurrent_executions: NotRequired[
+        "aws_sdk_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[
+        "aws_sdk_lambda.types.provisioned_concurrency_status_enum.ProvisionedConcurrencyStatusEnum"
+    ]
+    """<p>The status of the allocation process.</p>"""
+    status_reason: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>For failed allocations, the reason that provisioned concurrency could not be allocated.</p>"""
+    last_modified: NotRequired["aws_sdk_lambda.types.timestamp.Timestamp"]
+    """<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 aws_sdk_lambda.types.provisioned_concurrency_status_enum
+
+        out["Status"] = (
+            aws_sdk_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 aws_sdk_lambda.types.provisioned_concurrency_status_enum
+
+        out["status"] = (
+            aws_sdk_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

aws_sdk_lambda/types/put_runtime_management_config_request.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutRuntimeManagementConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.namespaced_function_name
+    import aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier
+    import aws_sdk_lambda.types.runtime_version_arn
+    import aws_sdk_lambda.types.update_runtime_on
+
+
+class PutRuntimeManagementConfigRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    )
+    """<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[
+        "aws_sdk_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: "aws_sdk_lambda.types.update_runtime_on.UpdateRuntimeOn"
+    """<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[
+        "aws_sdk_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 aws_sdk_lambda.types.update_runtime_on
+
+    out["UpdateRuntimeOn"] = aws_sdk_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 aws_sdk_lambda.types.update_runtime_on
+
+        out["update_runtime_on"] = (
+            aws_sdk_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

aws_sdk_lambda/types/put_runtime_management_config_response.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutRuntimeManagementConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_arn
+    import aws_sdk_lambda.types.runtime_version_arn
+    import aws_sdk_lambda.types.update_runtime_on
+
+
+class PutRuntimeManagementConfigResponse(TypedDict):
+    update_runtime_on: "aws_sdk_lambda.types.update_runtime_on.UpdateRuntimeOn"
+    """<p>The runtime update mode.</p>"""
+    function_arn: "aws_sdk_lambda.types.function_arn.FunctionArn"
+    """<p>The ARN of the function</p>"""
+    runtime_version_arn: NotRequired[
+        "aws_sdk_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 aws_sdk_lambda.types.update_runtime_on
+
+    out["UpdateRuntimeOn"] = aws_sdk_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 aws_sdk_lambda.types.update_runtime_on
+
+        out["update_runtime_on"] = (
+            aws_sdk_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

aws_sdk_lambda/types/qualifier.py

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

aws_sdk_lambda/types/queue.py

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

aws_sdk_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 aws_sdk_lambda.types.queue
+
+Queues: TypeAlias = list["aws_sdk_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)

aws_sdk_lambda/types/recursive_loop.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RecursiveLoop``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+RecursiveLoop: TypeAlias = Literal[
+    "Allow",
+    "Terminate",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "Allow",
+        "Terminate",
+    )
+)
+
+
+def serialize_json(value: RecursiveLoop) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> RecursiveLoop:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown RecursiveLoop value: {data!r}")
+    return cast(RecursiveLoop, data)

aws_sdk_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, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.layer_name
+    import aws_sdk_lambda.types.layer_version_number
+    import aws_sdk_lambda.types.statement_id
+    import aws_sdk_lambda.types.string
+
+
+class RemoveLayerVersionPermissionRequest(TypedDict):
+    layer_name: "aws_sdk_lambda.types.layer_name.LayerName"
+    """<p>The name or Amazon Resource Name (ARN) of the layer.</p>"""
+    version_number: "aws_sdk_lambda.types.layer_version_number.LayerVersionNumber"
+    """<p>The version number.</p>"""
+    statement_id: "aws_sdk_lambda.types.statement_id.StatementId"
+    """<p>The identifier that was specified when the statement was added.</p>"""
+    revision_id: NotRequired["aws_sdk_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