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

aws_sdk_lambda/types/function_list.py

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

aws_sdk_lambda/types/function_name.py

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

aws_sdk_lambda/types/function_response_type.py

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

aws_sdk_lambda/types/function_response_type_list.py

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

aws_sdk_lambda/types/function_scaling_config.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionScalingConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.function_scaling_config_execution_environments
+
+
+class FunctionScalingConfig(TypedDict):
+    min_execution_environments: NotRequired[
+        "aws_sdk_lambda.types.function_scaling_config_execution_environments.FunctionScalingConfigExecutionEnvironments"
+    ]
+    """<p>The minimum number of execution environments to maintain for the function.</p>"""
+    max_execution_environments: NotRequired[
+        "aws_sdk_lambda.types.function_scaling_config_execution_environments.FunctionScalingConfigExecutionEnvironments"
+    ]
+    """<p>The maximum number of execution environments that can be provisioned for the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionScalingConfig) -> dict:
+    out: dict = {}
+    if "min_execution_environments" in value:
+        out["MinExecutionEnvironments"] = value["min_execution_environments"]
+    if "max_execution_environments" in value:
+        out["MaxExecutionEnvironments"] = value["max_execution_environments"]
+    return out
+
+
+def deserialize_json(data: dict) -> FunctionScalingConfig:
+    out: FunctionScalingConfig = {}  # type: ignore[typeddict-item]
+    if "MinExecutionEnvironments" in data:
+        out["min_execution_environments"] = data["MinExecutionEnvironments"]
+    if "MaxExecutionEnvironments" in data:
+        out["max_execution_environments"] = data["MaxExecutionEnvironments"]
+    return out

aws_sdk_lambda/types/function_scaling_config_execution_environments.py

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

aws_sdk_lambda/types/function_url.py

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

aws_sdk_lambda/types/function_url_auth_type.py

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

aws_sdk_lambda/types/function_url_config.py

@@ -0,0 +1,96 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionUrlConfig``."""
+
+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 FunctionUrlConfig(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>"""
+    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>"""
+    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>"""
+    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\">Security and auth model for Lambda function URLs</a>.</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: FunctionUrlConfig) -> dict:
+    out: dict = {}
+    out["FunctionUrl"] = value["function_url"]
+    out["FunctionArn"] = value["function_arn"]
+    out["CreationTime"] = value["creation_time"]
+    out["LastModifiedTime"] = value["last_modified_time"]
+    if "cors" in value:
+        import aws_sdk_lambda.types.cors
+
+        out["Cors"] = aws_sdk_lambda.types.cors.serialize_json(value["cors"])
+    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 "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) -> FunctionUrlConfig:
+    out: FunctionUrlConfig = {}  # type: ignore[typeddict-item]
+    if "FunctionUrl" in data:
+        out["function_url"] = data["FunctionUrl"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.function_url required")
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.function_arn required")
+    if "CreationTime" in data:
+        out["creation_time"] = data["CreationTime"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.creation_time required")
+    if "LastModifiedTime" in data:
+        out["last_modified_time"] = data["LastModifiedTime"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.last_modified_time required")
+    if "Cors" in data:
+        import aws_sdk_lambda.types.cors
+
+        out["cors"] = aws_sdk_lambda.types.cors.deserialize_json(data["Cors"])
+    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("FunctionUrlConfig.auth_type 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/function_url_config_list.py

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

aws_sdk_lambda/types/function_url_qualifier.py

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

aws_sdk_lambda/types/function_version.py

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

aws_sdk_lambda/types/function_version_latest_published.py

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

aws_sdk_lambda/types/function_versions_by_capacity_provider_list.py

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

aws_sdk_lambda/types/function_versions_by_capacity_provider_list_item.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionVersionsByCapacityProviderListItem``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.name_spaced_function_arn
+    import aws_sdk_lambda.types.state
+
+
+class FunctionVersionsByCapacityProviderListItem(TypedDict):
+    function_arn: "aws_sdk_lambda.types.name_spaced_function_arn.NameSpacedFunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the function version.</p>"""
+    state: "aws_sdk_lambda.types.state.State"
+    """<p>The current state of the function version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionVersionsByCapacityProviderListItem) -> dict:
+    out: dict = {}
+    out["FunctionArn"] = value["function_arn"]
+    import aws_sdk_lambda.types.state
+
+    out["State"] = aws_sdk_lambda.types.state.serialize_json(value["state"])
+    return out
+
+
+def deserialize_json(data: dict) -> FunctionVersionsByCapacityProviderListItem:
+    out: FunctionVersionsByCapacityProviderListItem = {}  # type: ignore[typeddict-item]
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError(
+            "FunctionVersionsByCapacityProviderListItem.function_arn required"
+        )
+    if "State" in data:
+        import aws_sdk_lambda.types.state
+
+        out["state"] = aws_sdk_lambda.types.state.deserialize_json(data["State"])
+    else:
+        raise DeserializationError(
+            "FunctionVersionsByCapacityProviderListItem.state required"
+        )
+    return out

aws_sdk_lambda/types/get_account_settings_request.py

@@ -0,0 +1,18 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetAccountSettingsRequest``."""
+
+from typing import TypedDict
+
+
+class GetAccountSettingsRequest(TypedDict):
+    pass
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAccountSettingsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetAccountSettingsRequest:
+    out: GetAccountSettingsRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_account_settings_response.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetAccountSettingsResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.account_limit
+    import aws_sdk_lambda.types.account_usage
+
+
+class GetAccountSettingsResponse(TypedDict):
+    account_limit: NotRequired["aws_sdk_lambda.types.account_limit.AccountLimit"]
+    """<p>Limits that are related to concurrency and code storage.</p>"""
+    account_usage: NotRequired["aws_sdk_lambda.types.account_usage.AccountUsage"]
+    """<p>The number of functions and amount of storage in use.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAccountSettingsResponse) -> dict:
+    out: dict = {}
+    if "account_limit" in value:
+        import aws_sdk_lambda.types.account_limit
+
+        out["AccountLimit"] = aws_sdk_lambda.types.account_limit.serialize_json(
+            value["account_limit"]
+        )
+    if "account_usage" in value:
+        import aws_sdk_lambda.types.account_usage
+
+        out["AccountUsage"] = aws_sdk_lambda.types.account_usage.serialize_json(
+            value["account_usage"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetAccountSettingsResponse:
+    out: GetAccountSettingsResponse = {}  # type: ignore[typeddict-item]
+    if "AccountLimit" in data:
+        import aws_sdk_lambda.types.account_limit
+
+        out["account_limit"] = aws_sdk_lambda.types.account_limit.deserialize_json(
+            data["AccountLimit"]
+        )
+    if "AccountUsage" in data:
+        import aws_sdk_lambda.types.account_usage
+
+        out["account_usage"] = aws_sdk_lambda.types.account_usage.deserialize_json(
+            data["AccountUsage"]
+        )
+    return out

aws_sdk_lambda/types/get_alias_request.py

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

aws_sdk_lambda/types/get_capacity_provider_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCapacityProviderRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.capacity_provider_name
+
+
+class GetCapacityProviderRequest(TypedDict):
+    capacity_provider_name: (
+        "aws_sdk_lambda.types.capacity_provider_name.CapacityProviderName"
+    )
+    """<p>The name of the capacity provider to retrieve.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCapacityProviderRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetCapacityProviderRequest:
+    out: GetCapacityProviderRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_capacity_provider_response.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCapacityProviderResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.capacity_provider
+
+
+class GetCapacityProviderResponse(TypedDict):
+    capacity_provider: "aws_sdk_lambda.types.capacity_provider.CapacityProvider"
+    """<p>Information about the capacity provider, including its configuration and current state.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCapacityProviderResponse) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.capacity_provider
+
+    out["CapacityProvider"] = aws_sdk_lambda.types.capacity_provider.serialize_json(
+        value["capacity_provider"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetCapacityProviderResponse:
+    out: GetCapacityProviderResponse = {}  # type: ignore[typeddict-item]
+    if "CapacityProvider" in data:
+        import aws_sdk_lambda.types.capacity_provider
+
+        out["capacity_provider"] = (
+            aws_sdk_lambda.types.capacity_provider.deserialize_json(
+                data["CapacityProvider"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetCapacityProviderResponse.capacity_provider required"
+        )
+    return out

aws_sdk_lambda/types/get_code_signing_config_request.py

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

aws_sdk_lambda/types/get_code_signing_config_response.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCodeSigningConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.code_signing_config
+
+
+class GetCodeSigningConfigResponse(TypedDict):
+    code_signing_config: "aws_sdk_lambda.types.code_signing_config.CodeSigningConfig"
+    """<p>The code signing configuration</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCodeSigningConfigResponse) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.code_signing_config
+
+    out["CodeSigningConfig"] = aws_sdk_lambda.types.code_signing_config.serialize_json(
+        value["code_signing_config"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetCodeSigningConfigResponse:
+    out: GetCodeSigningConfigResponse = {}  # type: ignore[typeddict-item]
+    if "CodeSigningConfig" in data:
+        import aws_sdk_lambda.types.code_signing_config
+
+        out["code_signing_config"] = (
+            aws_sdk_lambda.types.code_signing_config.deserialize_json(
+                data["CodeSigningConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetCodeSigningConfigResponse.code_signing_config required"
+        )
+    return out