capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/publish_layer_version_response.py

@@ -0,0 +1,127 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PublishLayerVersionResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.compatible_architectures
+    import capo_lambda.types.compatible_runtimes
+    import capo_lambda.types.description
+    import capo_lambda.types.layer_arn
+    import capo_lambda.types.layer_version_arn
+    import capo_lambda.types.layer_version_content_output
+    import capo_lambda.types.layer_version_number
+    import capo_lambda.types.license_info
+    import capo_lambda.types.timestamp
+
+
+class PublishLayerVersionResponse(TypedDict, closed=True):
+    content: NotRequired[
+        "capo_lambda.types.layer_version_content_output.LayerVersionContentOutput"
+    ]
+    """<p>Details about the layer version.</p>"""
+    layer_arn: NotRequired["capo_lambda.types.layer_arn.LayerArn"]
+    """<p>The ARN of the layer.</p>"""
+    layer_version_arn: NotRequired[
+        "capo_lambda.types.layer_version_arn.LayerVersionArn"
+    ]
+    """<p>The ARN of the layer version.</p>"""
+    description: NotRequired["capo_lambda.types.description.Description"]
+    """<p>The description of the version.</p>"""
+    created_date: NotRequired["capo_lambda.types.timestamp.Timestamp"]
+    r"""<p>The date that the layer version was created, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    version: "capo_lambda.types.layer_version_number.LayerVersionNumber"
+    """<p>The version number.</p>"""
+    compatible_runtimes: NotRequired[
+        "capo_lambda.types.compatible_runtimes.CompatibleRuntimes"
+    ]
+    r"""<p>The layer's compatible runtimes.</p> <p>The following list includes deprecated runtimes. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-deprecation-levels\">Runtime use after deprecation</a>.</p> <p>For a list of all currently supported runtimes, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtimes-supported\">Supported runtimes</a>.</p>"""
+    license_info: NotRequired["capo_lambda.types.license_info.LicenseInfo"]
+    """<p>The layer's software license.</p>"""
+    compatible_architectures: NotRequired[
+        "capo_lambda.types.compatible_architectures.CompatibleArchitectures"
+    ]
+    r"""<p>A list of compatible <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html\">instruction set architectures</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PublishLayerVersionResponse) -> dict:
+    out: dict = {}
+    if "content" in value:
+        import capo_lambda.types.layer_version_content_output
+
+        out["Content"] = capo_lambda.types.layer_version_content_output.serialize_json(
+            value["content"]
+        )
+    if "layer_arn" in value:
+        out["LayerArn"] = value["layer_arn"]
+    if "layer_version_arn" in value:
+        out["LayerVersionArn"] = value["layer_version_arn"]
+    if "description" in value:
+        out["Description"] = value["description"]
+    if "created_date" in value:
+        out["CreatedDate"] = value["created_date"]
+    out["Version"] = value.get("version", 0)
+    if "compatible_runtimes" in value:
+        import capo_lambda.types.compatible_runtimes
+
+        out["CompatibleRuntimes"] = (
+            capo_lambda.types.compatible_runtimes.serialize_json(
+                value["compatible_runtimes"]
+            )
+        )
+    if "license_info" in value:
+        out["LicenseInfo"] = value["license_info"]
+    if "compatible_architectures" in value:
+        import capo_lambda.types.compatible_architectures
+
+        out["CompatibleArchitectures"] = (
+            capo_lambda.types.compatible_architectures.serialize_json(
+                value["compatible_architectures"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PublishLayerVersionResponse:
+    out: PublishLayerVersionResponse = {}  # type: ignore[typeddict-item]
+    if "Content" in data:
+        import capo_lambda.types.layer_version_content_output
+
+        out["content"] = (
+            capo_lambda.types.layer_version_content_output.deserialize_json(
+                data["Content"]
+            )
+        )
+    if "LayerArn" in data:
+        out["layer_arn"] = data["LayerArn"]
+    if "LayerVersionArn" in data:
+        out["layer_version_arn"] = data["LayerVersionArn"]
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "CreatedDate" in data:
+        out["created_date"] = data["CreatedDate"]
+    if "Version" in data:
+        out["version"] = data["Version"]
+    else:
+        out["version"] = 0
+    if "CompatibleRuntimes" in data:
+        import capo_lambda.types.compatible_runtimes
+
+        out["compatible_runtimes"] = (
+            capo_lambda.types.compatible_runtimes.deserialize_json(
+                data["CompatibleRuntimes"]
+            )
+        )
+    if "LicenseInfo" in data:
+        out["license_info"] = data["LicenseInfo"]
+    if "CompatibleArchitectures" in data:
+        import capo_lambda.types.compatible_architectures
+
+        out["compatible_architectures"] = (
+            capo_lambda.types.compatible_architectures.deserialize_json(
+                data["CompatibleArchitectures"]
+            )
+        )
+    return out

capo_lambda/types/publish_version_request.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PublishVersionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.description
+    import capo_lambda.types.function_name
+    import capo_lambda.types.function_version_latest_published
+    import capo_lambda.types.string
+
+
+class PublishVersionRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.function_name.FunctionName"
+    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>MyFunction</code>.</p> </li> <li> <p> <b>Function ARN</b> - <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction</code>.</p> </li> <li> <p> <b>Partial ARN</b> - <code>123456789012:function:MyFunction</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>"""
+    code_sha256: NotRequired["capo_lambda.types.string.String"]
+    """<p>Only publish a version if the hash value matches the value that's specified. Use this option to avoid publishing a version if the function code has changed since you last updated it. You can get the hash for the version that you uploaded from the output of <a>UpdateFunctionCode</a>.</p>"""
+    description: NotRequired["capo_lambda.types.description.Description"]
+    """<p>A description for the version to override the description in the function configuration.</p>"""
+    revision_id: NotRequired["capo_lambda.types.string.String"]
+    """<p>Only update the function if the revision ID matches the ID that's specified. Use this option to avoid publishing a version if the function configuration has changed since you last updated it.</p>"""
+    publish_to: NotRequired[
+        "capo_lambda.types.function_version_latest_published.FunctionVersionLatestPublished"
+    ]
+    """<p>Specifies where to publish the function version or configuration.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PublishVersionRequest) -> dict:
+    out: dict = {}
+    if "code_sha256" in value:
+        out["CodeSha256"] = value["code_sha256"]
+    if "description" in value:
+        out["Description"] = value["description"]
+    if "revision_id" in value:
+        out["RevisionId"] = value["revision_id"]
+    if "publish_to" in value:
+        import capo_lambda.types.function_version_latest_published
+
+        out["PublishTo"] = (
+            capo_lambda.types.function_version_latest_published.serialize_json(
+                value["publish_to"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PublishVersionRequest:
+    out: PublishVersionRequest = {}  # type: ignore[typeddict-item]
+    if "CodeSha256" in data:
+        out["code_sha256"] = data["CodeSha256"]
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "RevisionId" in data:
+        out["revision_id"] = data["RevisionId"]
+    if "PublishTo" in data:
+        import capo_lambda.types.function_version_latest_published
+
+        out["publish_to"] = (
+            capo_lambda.types.function_version_latest_published.deserialize_json(
+                data["PublishTo"]
+            )
+        )
+    return out

capo_lambda/types/published_function_qualifier.py

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

capo_lambda/types/put_function_code_signing_config_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionCodeSigningConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.code_signing_config_arn
+    import capo_lambda.types.namespaced_function_name
+
+
+class PutFunctionCodeSigningConfigRequest(TypedDict, closed=True):
+    code_signing_config_arn: (
+        "capo_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration.</p>"""
+    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>MyFunction</code>.</p> </li> <li> <p> <b>Function ARN</b> - <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction</code>.</p> </li> <li> <p> <b>Partial ARN</b> - <code>123456789012:function:MyFunction</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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionCodeSigningConfigRequest) -> dict:
+    out: dict = {}
+    out["CodeSigningConfigArn"] = value["code_signing_config_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionCodeSigningConfigRequest:
+    out: PutFunctionCodeSigningConfigRequest = {}  # type: ignore[typeddict-item]
+    if "CodeSigningConfigArn" in data:
+        out["code_signing_config_arn"] = data["CodeSigningConfigArn"]
+    else:
+        raise DeserializationError(
+            "PutFunctionCodeSigningConfigRequest.code_signing_config_arn required"
+        )
+    return out

capo_lambda/types/put_function_code_signing_config_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionCodeSigningConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.code_signing_config_arn
+    import capo_lambda.types.function_name
+
+
+class PutFunctionCodeSigningConfigResponse(TypedDict, closed=True):
+    code_signing_config_arn: (
+        "capo_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration.</p>"""
+    function_name: "capo_lambda.types.function_name.FunctionName"
+    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>MyFunction</code>.</p> </li> <li> <p> <b>Function ARN</b> - <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction</code>.</p> </li> <li> <p> <b>Partial ARN</b> - <code>123456789012:function:MyFunction</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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutFunctionCodeSigningConfigResponse) -> dict:
+    out: dict = {}
+    out["CodeSigningConfigArn"] = value["code_signing_config_arn"]
+    out["FunctionName"] = value["function_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutFunctionCodeSigningConfigResponse:
+    out: PutFunctionCodeSigningConfigResponse = {}  # type: ignore[typeddict-item]
+    if "CodeSigningConfigArn" in data:
+        out["code_signing_config_arn"] = data["CodeSigningConfigArn"]
+    else:
+        raise DeserializationError(
+            "PutFunctionCodeSigningConfigResponse.code_signing_config_arn required"
+        )
+    if "FunctionName" in data:
+        out["function_name"] = data["FunctionName"]
+    else:
+        raise DeserializationError(
+            "PutFunctionCodeSigningConfigResponse.function_name required"
+        )
+    return out

capo_lambda/types/put_function_concurrency_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionConcurrencyRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_name
+    import capo_lambda.types.reserved_concurrent_executions
+
+
+class PutFunctionConcurrencyRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.function_name.FunctionName"
+    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>"""
+    reserved_concurrent_executions: (
+        "capo_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

capo_lambda/types/put_function_event_invoke_config_request.py

@@ -0,0 +1,66 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionEventInvokeConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.destination_config
+    import capo_lambda.types.maximum_event_age_in_seconds
+    import capo_lambda.types.maximum_retry_attempts
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+
+
+class PutFunctionEventInvokeConfigRequest(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>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>A version number or alias name.</p>"""
+    maximum_retry_attempts: NotRequired[
+        "capo_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[
+        "capo_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[
+        "capo_lambda.types.destination_config.DestinationConfig"
+    ]
+    r"""<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 capo_lambda.types.destination_config
+
+        out["DestinationConfig"] = capo_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 capo_lambda.types.destination_config
+
+        out["destination_config"] = (
+            capo_lambda.types.destination_config.deserialize_json(
+                data["DestinationConfig"]
+            )
+        )
+    return out

capo_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
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.recursive_loop
+    import capo_lambda.types.unqualified_function_name
+
+
+class PutFunctionRecursionConfigRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.unqualified_function_name.UnqualifiedFunctionName"
+    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>"""
+    recursive_loop: "capo_lambda.types.recursive_loop.RecursiveLoop"
+    r"""<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 capo_lambda.types.recursive_loop
+
+    out["RecursiveLoop"] = capo_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 capo_lambda.types.recursive_loop
+
+        out["recursive_loop"] = capo_lambda.types.recursive_loop.deserialize_json(
+            data["RecursiveLoop"]
+        )
+    else:
+        raise DeserializationError(
+            "PutFunctionRecursionConfigRequest.recursive_loop required"
+        )
+    return out

capo_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
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.recursive_loop
+
+
+class PutFunctionRecursionConfigResponse(TypedDict, closed=True):
+    recursive_loop: NotRequired["capo_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 capo_lambda.types.recursive_loop
+
+        out["RecursiveLoop"] = capo_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 capo_lambda.types.recursive_loop
+
+        out["recursive_loop"] = capo_lambda.types.recursive_loop.deserialize_json(
+            data["RecursiveLoop"]
+        )
+    return out

capo_lambda/types/put_function_scaling_config_request.py

@@ -0,0 +1,50 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionScalingConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_scaling_config
+    import capo_lambda.types.published_function_qualifier
+    import capo_lambda.types.unqualified_function_name
+
+
+class PutFunctionScalingConfigRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.unqualified_function_name.UnqualifiedFunctionName"
+    """<p>The name or ARN of the Lambda function.</p>"""
+    qualifier: (
+        "capo_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[
+        "capo_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 capo_lambda.types.function_scaling_config
+
+        out["FunctionScalingConfig"] = (
+            capo_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 capo_lambda.types.function_scaling_config
+
+        out["function_scaling_config"] = (
+            capo_lambda.types.function_scaling_config.deserialize_json(
+                data["FunctionScalingConfig"]
+            )
+        )
+    return out

capo_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
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.state
+
+
+class PutFunctionScalingConfigResponse(TypedDict, closed=True):
+    function_state: NotRequired["capo_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 capo_lambda.types.state
+
+        out["FunctionState"] = capo_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 capo_lambda.types.state
+
+        out["function_state"] = capo_lambda.types.state.deserialize_json(
+            data["FunctionState"]
+        )
+    return out

capo_lambda/types/put_provisioned_concurrency_config_request.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutProvisionedConcurrencyConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_name
+    import capo_lambda.types.positive_integer
+    import capo_lambda.types.qualifier
+
+
+class PutProvisionedConcurrencyConfigRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.function_name.FunctionName"
+    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: "capo_lambda.types.qualifier.Qualifier"
+    """<p>The version number or alias name.</p>"""
+    provisioned_concurrent_executions: (
+        "capo_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