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

aws_sdk_lambda/types/get_function_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.namespaced_function_name
+    import aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier
+
+
+class GetFunctionRequest(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>Specify a version or alias to get details about a published version of the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionRequest:
+    out: GetFunctionRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_response.py

@@ -0,0 +1,100 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.concurrency
+    import aws_sdk_lambda.types.function_code_location
+    import aws_sdk_lambda.types.function_configuration
+    import aws_sdk_lambda.types.tags
+    import aws_sdk_lambda.types.tags_error
+
+
+class GetFunctionResponse(TypedDict):
+    configuration: NotRequired[
+        "aws_sdk_lambda.types.function_configuration.FunctionConfiguration"
+    ]
+    """<p>The configuration of the function or version.</p>"""
+    code: NotRequired[
+        "aws_sdk_lambda.types.function_code_location.FunctionCodeLocation"
+    ]
+    """<p>The deployment package of the function or version.</p>"""
+    tags: NotRequired["aws_sdk_lambda.types.tags.Tags"]
+    """<p>The function's <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/tagging.html\">tags</a>. Lambda returns tag data only if you have explicit allow permissions for <a href=\"https://docs.aws.amazon.com/lambda/latest/api/API_ListTags.html\">lambda:ListTags</a>.</p>"""
+    tags_error: NotRequired["aws_sdk_lambda.types.tags_error.TagsError"]
+    """<p>An object that contains details about an error related to retrieving tags.</p>"""
+    concurrency: NotRequired["aws_sdk_lambda.types.concurrency.Concurrency"]
+    """<p>The function's <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/concurrent-executions.html\">reserved concurrency</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionResponse) -> dict:
+    out: dict = {}
+    if "configuration" in value:
+        import aws_sdk_lambda.types.function_configuration
+
+        out["Configuration"] = (
+            aws_sdk_lambda.types.function_configuration.serialize_json(
+                value["configuration"]
+            )
+        )
+    if "code" in value:
+        import aws_sdk_lambda.types.function_code_location
+
+        out["Code"] = aws_sdk_lambda.types.function_code_location.serialize_json(
+            value["code"]
+        )
+    if "tags" in value:
+        import aws_sdk_lambda.types.tags
+
+        out["Tags"] = aws_sdk_lambda.types.tags.serialize_json(value["tags"])
+    if "tags_error" in value:
+        import aws_sdk_lambda.types.tags_error
+
+        out["TagsError"] = aws_sdk_lambda.types.tags_error.serialize_json(
+            value["tags_error"]
+        )
+    if "concurrency" in value:
+        import aws_sdk_lambda.types.concurrency
+
+        out["Concurrency"] = aws_sdk_lambda.types.concurrency.serialize_json(
+            value["concurrency"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionResponse:
+    out: GetFunctionResponse = {}  # type: ignore[typeddict-item]
+    if "Configuration" in data:
+        import aws_sdk_lambda.types.function_configuration
+
+        out["configuration"] = (
+            aws_sdk_lambda.types.function_configuration.deserialize_json(
+                data["Configuration"]
+            )
+        )
+    if "Code" in data:
+        import aws_sdk_lambda.types.function_code_location
+
+        out["code"] = aws_sdk_lambda.types.function_code_location.deserialize_json(
+            data["Code"]
+        )
+    if "Tags" in data:
+        import aws_sdk_lambda.types.tags
+
+        out["tags"] = aws_sdk_lambda.types.tags.deserialize_json(data["Tags"])
+    if "TagsError" in data:
+        import aws_sdk_lambda.types.tags_error
+
+        out["tags_error"] = aws_sdk_lambda.types.tags_error.deserialize_json(
+            data["TagsError"]
+        )
+    if "Concurrency" in data:
+        import aws_sdk_lambda.types.concurrency
+
+        out["concurrency"] = aws_sdk_lambda.types.concurrency.deserialize_json(
+            data["Concurrency"]
+        )
+    return out

aws_sdk_lambda/types/get_function_scaling_config_request.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionScalingConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.published_function_qualifier
+    import aws_sdk_lambda.types.unqualified_function_name
+
+
+class GetFunctionScalingConfigRequest(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 get the scaling configuration for a published version of the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionScalingConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionScalingConfigRequest:
+    out: GetFunctionScalingConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_scaling_config_response.py

@@ -0,0 +1,69 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionScalingConfigResponse``."""
+
+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.function_scaling_config
+
+
+class GetFunctionScalingConfigResponse(TypedDict):
+    function_arn: NotRequired["aws_sdk_lambda.types.function_arn.FunctionArn"]
+    """<p>The Amazon Resource Name (ARN) of the function.</p>"""
+    applied_function_scaling_config: NotRequired[
+        "aws_sdk_lambda.types.function_scaling_config.FunctionScalingConfig"
+    ]
+    """<p>The scaling configuration that is currently applied to the function. This represents the actual scaling settings in effect.</p>"""
+    requested_function_scaling_config: NotRequired[
+        "aws_sdk_lambda.types.function_scaling_config.FunctionScalingConfig"
+    ]
+    """<p>The scaling configuration that was requested for the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionScalingConfigResponse) -> dict:
+    out: dict = {}
+    if "function_arn" in value:
+        out["FunctionArn"] = value["function_arn"]
+    if "applied_function_scaling_config" in value:
+        import aws_sdk_lambda.types.function_scaling_config
+
+        out["AppliedFunctionScalingConfig"] = (
+            aws_sdk_lambda.types.function_scaling_config.serialize_json(
+                value["applied_function_scaling_config"]
+            )
+        )
+    if "requested_function_scaling_config" in value:
+        import aws_sdk_lambda.types.function_scaling_config
+
+        out["RequestedFunctionScalingConfig"] = (
+            aws_sdk_lambda.types.function_scaling_config.serialize_json(
+                value["requested_function_scaling_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionScalingConfigResponse:
+    out: GetFunctionScalingConfigResponse = {}  # type: ignore[typeddict-item]
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    if "AppliedFunctionScalingConfig" in data:
+        import aws_sdk_lambda.types.function_scaling_config
+
+        out["applied_function_scaling_config"] = (
+            aws_sdk_lambda.types.function_scaling_config.deserialize_json(
+                data["AppliedFunctionScalingConfig"]
+            )
+        )
+    if "RequestedFunctionScalingConfig" in data:
+        import aws_sdk_lambda.types.function_scaling_config
+
+        out["requested_function_scaling_config"] = (
+            aws_sdk_lambda.types.function_scaling_config.deserialize_json(
+                data["RequestedFunctionScalingConfig"]
+            )
+        )
+    return out

aws_sdk_lambda/types/get_function_url_config_request.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionUrlConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_name
+    import aws_sdk_lambda.types.function_url_qualifier
+
+
+class GetFunctionUrlConfigRequest(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: NotRequired[
+        "aws_sdk_lambda.types.function_url_qualifier.FunctionUrlQualifier"
+    ]
+    """<p>The alias name.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionUrlConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionUrlConfigRequest:
+    out: GetFunctionUrlConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_url_config_response.py

@@ -0,0 +1,100 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionUrlConfigResponse``."""
+
+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.cors
+    import aws_sdk_lambda.types.function_arn
+    import aws_sdk_lambda.types.function_url
+    import aws_sdk_lambda.types.function_url_auth_type
+    import aws_sdk_lambda.types.invoke_mode
+    import aws_sdk_lambda.types.timestamp
+
+
+class GetFunctionUrlConfigResponse(TypedDict):
+    function_url: "aws_sdk_lambda.types.function_url.FunctionUrl"
+    """<p>The HTTP URL endpoint for your function.</p>"""
+    function_arn: "aws_sdk_lambda.types.function_arn.FunctionArn"
+    """<p>The Amazon Resource Name (ARN) of your function.</p>"""
+    auth_type: "aws_sdk_lambda.types.function_url_auth_type.FunctionUrlAuthType"
+    """<p>The type of authentication that your function URL uses. Set to <code>AWS_IAM</code> if you want to restrict access to authenticated users only. Set to <code>NONE</code> if you want to bypass IAM authentication to create a public endpoint. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html\">Control access to Lambda function URLs</a>.</p>"""
+    cors: NotRequired["aws_sdk_lambda.types.cors.Cors"]
+    """<p>The <a href=\"https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS\">cross-origin resource sharing (CORS)</a> settings for your function URL.</p>"""
+    creation_time: "aws_sdk_lambda.types.timestamp.Timestamp"
+    """<p>When the function URL was created, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    last_modified_time: "aws_sdk_lambda.types.timestamp.Timestamp"
+    """<p>When the function URL configuration was last updated, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    invoke_mode: NotRequired["aws_sdk_lambda.types.invoke_mode.InvokeMode"]
+    """<p>Use one of the following options:</p> <ul> <li> <p> <code>BUFFERED</code> – This is the default option. Lambda invokes your function using the <code>Invoke</code> API operation. Invocation results are available when the payload is complete. The maximum payload size is 6 MB.</p> </li> <li> <p> <code>RESPONSE_STREAM</code> – Your function streams payload results as they become available. Lambda invokes your function using the <code>InvokeWithResponseStream</code> API operation. The maximum response payload size is 200 MB.</p> </li> </ul>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionUrlConfigResponse) -> dict:
+    out: dict = {}
+    out["FunctionUrl"] = value["function_url"]
+    out["FunctionArn"] = value["function_arn"]
+    import aws_sdk_lambda.types.function_url_auth_type
+
+    out["AuthType"] = aws_sdk_lambda.types.function_url_auth_type.serialize_json(
+        value["auth_type"]
+    )
+    if "cors" in value:
+        import aws_sdk_lambda.types.cors
+
+        out["Cors"] = aws_sdk_lambda.types.cors.serialize_json(value["cors"])
+    out["CreationTime"] = value["creation_time"]
+    out["LastModifiedTime"] = value["last_modified_time"]
+    if "invoke_mode" in value:
+        import aws_sdk_lambda.types.invoke_mode
+
+        out["InvokeMode"] = aws_sdk_lambda.types.invoke_mode.serialize_json(
+            value["invoke_mode"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionUrlConfigResponse:
+    out: GetFunctionUrlConfigResponse = {}  # type: ignore[typeddict-item]
+    if "FunctionUrl" in data:
+        out["function_url"] = data["FunctionUrl"]
+    else:
+        raise DeserializationError("GetFunctionUrlConfigResponse.function_url required")
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError("GetFunctionUrlConfigResponse.function_arn required")
+    if "AuthType" in data:
+        import aws_sdk_lambda.types.function_url_auth_type
+
+        out["auth_type"] = aws_sdk_lambda.types.function_url_auth_type.deserialize_json(
+            data["AuthType"]
+        )
+    else:
+        raise DeserializationError("GetFunctionUrlConfigResponse.auth_type required")
+    if "Cors" in data:
+        import aws_sdk_lambda.types.cors
+
+        out["cors"] = aws_sdk_lambda.types.cors.deserialize_json(data["Cors"])
+    if "CreationTime" in data:
+        out["creation_time"] = data["CreationTime"]
+    else:
+        raise DeserializationError(
+            "GetFunctionUrlConfigResponse.creation_time required"
+        )
+    if "LastModifiedTime" in data:
+        out["last_modified_time"] = data["LastModifiedTime"]
+    else:
+        raise DeserializationError(
+            "GetFunctionUrlConfigResponse.last_modified_time required"
+        )
+    if "InvokeMode" in data:
+        import aws_sdk_lambda.types.invoke_mode
+
+        out["invoke_mode"] = aws_sdk_lambda.types.invoke_mode.deserialize_json(
+            data["InvokeMode"]
+        )
+    return out

aws_sdk_lambda/types/get_layer_version_by_arn_request.py

@@ -0,0 +1,22 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetLayerVersionByArnRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.layer_version_arn
+
+
+class GetLayerVersionByArnRequest(TypedDict):
+    arn: "aws_sdk_lambda.types.layer_version_arn.LayerVersionArn"
+    """<p>The ARN of the layer version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetLayerVersionByArnRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetLayerVersionByArnRequest:
+    out: GetLayerVersionByArnRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_layer_version_policy_request.py

@@ -0,0 +1,25 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetLayerVersionPolicyRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.layer_name
+    import aws_sdk_lambda.types.layer_version_number
+
+
+class GetLayerVersionPolicyRequest(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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetLayerVersionPolicyRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetLayerVersionPolicyRequest:
+    out: GetLayerVersionPolicyRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_layer_version_policy_response.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetLayerVersionPolicyResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class GetLayerVersionPolicyResponse(TypedDict):
+    policy: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The policy document.</p>"""
+    revision_id: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>A unique identifier for the current revision of the policy.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetLayerVersionPolicyResponse) -> dict:
+    out: dict = {}
+    if "policy" in value:
+        out["Policy"] = value["policy"]
+    if "revision_id" in value:
+        out["RevisionId"] = value["revision_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetLayerVersionPolicyResponse:
+    out: GetLayerVersionPolicyResponse = {}  # type: ignore[typeddict-item]
+    if "Policy" in data:
+        out["policy"] = data["Policy"]
+    if "RevisionId" in data:
+        out["revision_id"] = data["RevisionId"]
+    return out

aws_sdk_lambda/types/get_layer_version_request.py

@@ -0,0 +1,25 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetLayerVersionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.layer_name
+    import aws_sdk_lambda.types.layer_version_number
+
+
+class GetLayerVersionRequest(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>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetLayerVersionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetLayerVersionRequest:
+    out: GetLayerVersionRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_layer_version_response.py

@@ -0,0 +1,129 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetLayerVersionResponse``."""
+
+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 GetLayerVersionResponse(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: GetLayerVersionResponse) -> 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) -> GetLayerVersionResponse:
+    out: GetLayerVersionResponse = {}  # 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/get_policy_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetPolicyRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.namespaced_function_name
+    import aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier
+
+
+class GetPolicyRequest(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>Specify a version or alias to get the policy for that resource.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetPolicyRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetPolicyRequest:
+    out: GetPolicyRequest = {}  # type: ignore[typeddict-item]
+    return out