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

aws_sdk_lambda/types/principal.py

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

aws_sdk_lambda/types/principal_org_id.py

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

aws_sdk_lambda/types/provisioned_concurrency_config_list.py

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

aws_sdk_lambda/types/provisioned_concurrency_config_list_item.py

@@ -0,0 +1,101 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ProvisionedConcurrencyConfigListItem``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_arn
+    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 ProvisionedConcurrencyConfigListItem(TypedDict):
+    function_arn: NotRequired["aws_sdk_lambda.types.function_arn.FunctionArn"]
+    """<p>The Amazon Resource Name (ARN) of the alias or version.</p>"""
+    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: ProvisionedConcurrencyConfigListItem) -> dict:
+    out: dict = {}
+    if "function_arn" in value:
+        out["FunctionArn"] = value["function_arn"]
+    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) -> ProvisionedConcurrencyConfigListItem:
+    out: ProvisionedConcurrencyConfigListItem = {}  # type: ignore[typeddict-item]
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    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/provisioned_concurrency_status_enum.py

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

aws_sdk_lambda/types/provisioned_poller_config.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ProvisionedPollerConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.maximum_number_of_pollers
+    import aws_sdk_lambda.types.minimum_number_of_pollers
+    import aws_sdk_lambda.types.provisioned_poller_group_name
+
+
+class ProvisionedPollerConfig(TypedDict):
+    minimum_pollers: NotRequired[
+        "aws_sdk_lambda.types.minimum_number_of_pollers.MinimumNumberOfPollers"
+    ]
+    """<p>The minimum number of event pollers this event source can scale down to. For Amazon SQS events source mappings, default is 2, and minimum 2 required. For Amazon MSK and self-managed Apache Kafka event source mappings, default is 1.</p>"""
+    maximum_pollers: NotRequired[
+        "aws_sdk_lambda.types.maximum_number_of_pollers.MaximumNumberOfPollers"
+    ]
+    """<p>The maximum number of event pollers this event source can scale up to. For Amazon SQS events source mappings, default is 200, and minimum value allowed is 2. For Amazon MSK and self-managed Apache Kafka event source mappings, default is 200, and minimum value allowed is 1.</p>"""
+    poller_group_name: NotRequired[
+        "aws_sdk_lambda.types.provisioned_poller_group_name.ProvisionedPollerGroupName"
+    ]
+    """<p>(Amazon MSK and self-managed Apache Kafka) The name of the provisioned poller group. Use this option to group multiple ESMs within the event source's VPC to share Event Poller Unit (EPU) capacity. You can use this option to optimize Provisioned mode costs for your ESMs. You can group up to 100 ESMs per poller group and aggregate maximum pollers across all ESMs in a group cannot exceed 2000.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProvisionedPollerConfig) -> dict:
+    out: dict = {}
+    if "minimum_pollers" in value:
+        out["MinimumPollers"] = value["minimum_pollers"]
+    if "maximum_pollers" in value:
+        out["MaximumPollers"] = value["maximum_pollers"]
+    if "poller_group_name" in value:
+        out["PollerGroupName"] = value["poller_group_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProvisionedPollerConfig:
+    out: ProvisionedPollerConfig = {}  # type: ignore[typeddict-item]
+    if "MinimumPollers" in data:
+        out["minimum_pollers"] = data["MinimumPollers"]
+    if "MaximumPollers" in data:
+        out["maximum_pollers"] = data["MaximumPollers"]
+    if "PollerGroupName" in data:
+        out["poller_group_name"] = data["PollerGroupName"]
+    return out

aws_sdk_lambda/types/provisioned_poller_group_name.py

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

aws_sdk_lambda/types/publish_layer_version_request.py

@@ -0,0 +1,100 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PublishLayerVersionRequest``."""
+
+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.compatible_architectures
+    import aws_sdk_lambda.types.compatible_runtimes
+    import aws_sdk_lambda.types.description
+    import aws_sdk_lambda.types.layer_name
+    import aws_sdk_lambda.types.layer_version_content_input
+    import aws_sdk_lambda.types.license_info
+
+
+class PublishLayerVersionRequest(TypedDict):
+    layer_name: "aws_sdk_lambda.types.layer_name.LayerName"
+    """<p>The name or Amazon Resource Name (ARN) of the layer.</p>"""
+    description: NotRequired["aws_sdk_lambda.types.description.Description"]
+    """<p>The description of the version.</p>"""
+    content: "aws_sdk_lambda.types.layer_version_content_input.LayerVersionContentInput"
+    """<p>The function layer archive.</p>"""
+    compatible_runtimes: NotRequired[
+        "aws_sdk_lambda.types.compatible_runtimes.CompatibleRuntimes"
+    ]
+    """<p>A list of compatible <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html\">function runtimes</a>. Used for filtering with <a>ListLayers</a> and <a>ListLayerVersions</a>.</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-support-policy\">Runtime deprecation policy</a>.</p>"""
+    license_info: NotRequired["aws_sdk_lambda.types.license_info.LicenseInfo"]
+    """<p>The layer's software license. It can be any of the following:</p> <ul> <li> <p>An <a href=\"https://spdx.org/licenses/\">SPDX license identifier</a>. For example, <code>MIT</code>.</p> </li> <li> <p>The URL of a license hosted on the internet. For example, <code>https://opensource.org/licenses/MIT</code>.</p> </li> <li> <p>The full text of the license.</p> </li> </ul>"""
+    compatible_architectures: NotRequired[
+        "aws_sdk_lambda.types.compatible_architectures.CompatibleArchitectures"
+    ]
+    """<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: PublishLayerVersionRequest) -> dict:
+    out: dict = {}
+    if "description" in value:
+        out["Description"] = value["description"]
+    import aws_sdk_lambda.types.layer_version_content_input
+
+    out["Content"] = aws_sdk_lambda.types.layer_version_content_input.serialize_json(
+        value["content"]
+    )
+    if "compatible_runtimes" in value:
+        import aws_sdk_lambda.types.compatible_runtimes
+
+        out["CompatibleRuntimes"] = (
+            aws_sdk_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 aws_sdk_lambda.types.compatible_architectures
+
+        out["CompatibleArchitectures"] = (
+            aws_sdk_lambda.types.compatible_architectures.serialize_json(
+                value["compatible_architectures"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PublishLayerVersionRequest:
+    out: PublishLayerVersionRequest = {}  # type: ignore[typeddict-item]
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "Content" in data:
+        import aws_sdk_lambda.types.layer_version_content_input
+
+        out["content"] = (
+            aws_sdk_lambda.types.layer_version_content_input.deserialize_json(
+                data["Content"]
+            )
+        )
+    else:
+        raise DeserializationError("PublishLayerVersionRequest.content required")
+    if "CompatibleRuntimes" in data:
+        import aws_sdk_lambda.types.compatible_runtimes
+
+        out["compatible_runtimes"] = (
+            aws_sdk_lambda.types.compatible_runtimes.deserialize_json(
+                data["CompatibleRuntimes"]
+            )
+        )
+    if "LicenseInfo" in data:
+        out["license_info"] = data["LicenseInfo"]
+    if "CompatibleArchitectures" in data:
+        import aws_sdk_lambda.types.compatible_architectures
+
+        out["compatible_architectures"] = (
+            aws_sdk_lambda.types.compatible_architectures.deserialize_json(
+                data["CompatibleArchitectures"]
+            )
+        )
+    return out

aws_sdk_lambda/types/publish_layer_version_response.py

@@ -0,0 +1,129 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PublishLayerVersionResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.compatible_architectures
+    import aws_sdk_lambda.types.compatible_runtimes
+    import aws_sdk_lambda.types.description
+    import aws_sdk_lambda.types.layer_arn
+    import aws_sdk_lambda.types.layer_version_arn
+    import aws_sdk_lambda.types.layer_version_content_output
+    import aws_sdk_lambda.types.layer_version_number
+    import aws_sdk_lambda.types.license_info
+    import aws_sdk_lambda.types.timestamp
+
+
+class PublishLayerVersionResponse(TypedDict):
+    content: NotRequired[
+        "aws_sdk_lambda.types.layer_version_content_output.LayerVersionContentOutput"
+    ]
+    """<p>Details about the layer version.</p>"""
+    layer_arn: NotRequired["aws_sdk_lambda.types.layer_arn.LayerArn"]
+    """<p>The ARN of the layer.</p>"""
+    layer_version_arn: NotRequired[
+        "aws_sdk_lambda.types.layer_version_arn.LayerVersionArn"
+    ]
+    """<p>The ARN of the layer version.</p>"""
+    description: NotRequired["aws_sdk_lambda.types.description.Description"]
+    """<p>The description of the version.</p>"""
+    created_date: NotRequired["aws_sdk_lambda.types.timestamp.Timestamp"]
+    """<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: "aws_sdk_lambda.types.layer_version_number.LayerVersionNumber"
+    """<p>The version number.</p>"""
+    compatible_runtimes: NotRequired[
+        "aws_sdk_lambda.types.compatible_runtimes.CompatibleRuntimes"
+    ]
+    """<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["aws_sdk_lambda.types.license_info.LicenseInfo"]
+    """<p>The layer's software license.</p>"""
+    compatible_architectures: NotRequired[
+        "aws_sdk_lambda.types.compatible_architectures.CompatibleArchitectures"
+    ]
+    """<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 aws_sdk_lambda.types.layer_version_content_output
+
+        out["Content"] = (
+            aws_sdk_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 aws_sdk_lambda.types.compatible_runtimes
+
+        out["CompatibleRuntimes"] = (
+            aws_sdk_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 aws_sdk_lambda.types.compatible_architectures
+
+        out["CompatibleArchitectures"] = (
+            aws_sdk_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 aws_sdk_lambda.types.layer_version_content_output
+
+        out["content"] = (
+            aws_sdk_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 aws_sdk_lambda.types.compatible_runtimes
+
+        out["compatible_runtimes"] = (
+            aws_sdk_lambda.types.compatible_runtimes.deserialize_json(
+                data["CompatibleRuntimes"]
+            )
+        )
+    if "LicenseInfo" in data:
+        out["license_info"] = data["LicenseInfo"]
+    if "CompatibleArchitectures" in data:
+        import aws_sdk_lambda.types.compatible_architectures
+
+        out["compatible_architectures"] = (
+            aws_sdk_lambda.types.compatible_architectures.deserialize_json(
+                data["CompatibleArchitectures"]
+            )
+        )
+    return out

aws_sdk_lambda/types/publish_version_request.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PublishVersionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.description
+    import aws_sdk_lambda.types.function_name
+    import aws_sdk_lambda.types.function_version_latest_published
+    import aws_sdk_lambda.types.string
+
+
+class PublishVersionRequest(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>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["aws_sdk_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["aws_sdk_lambda.types.description.Description"]
+    """<p>A description for the version to override the description in the function configuration.</p>"""
+    revision_id: NotRequired["aws_sdk_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[
+        "aws_sdk_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 aws_sdk_lambda.types.function_version_latest_published
+
+        out["PublishTo"] = (
+            aws_sdk_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 aws_sdk_lambda.types.function_version_latest_published
+
+        out["publish_to"] = (
+            aws_sdk_lambda.types.function_version_latest_published.deserialize_json(
+                data["PublishTo"]
+            )
+        )
+    return out

aws_sdk_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

aws_sdk_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, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.code_signing_config_arn
+    import aws_sdk_lambda.types.namespaced_function_name
+
+
+class PutFunctionCodeSigningConfigRequest(TypedDict):
+    code_signing_config_arn: (
+        "aws_sdk_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration.</p>"""
+    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>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

aws_sdk_lambda/types/put_function_code_signing_config_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PutFunctionCodeSigningConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.code_signing_config_arn
+    import aws_sdk_lambda.types.function_name
+
+
+class PutFunctionCodeSigningConfigResponse(TypedDict):
+    code_signing_config_arn: (
+        "aws_sdk_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration.</p>"""
+    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>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