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

aws_sdk_lambda/types/code_signing_policy.py

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

aws_sdk_lambda/types/collection_name.py

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

aws_sdk_lambda/types/compatible_architectures.py

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

aws_sdk_lambda/types/compatible_runtimes.py

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

aws_sdk_lambda/types/concurrency.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Concurrency``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.reserved_concurrent_executions
+
+
+class Concurrency(TypedDict):
+    reserved_concurrent_executions: NotRequired[
+        "aws_sdk_lambda.types.reserved_concurrent_executions.ReservedConcurrentExecutions"
+    ]
+    """<p>The number of concurrent executions that are reserved for this function. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/configuration-concurrency.html\">Managing Lambda reserved concurrency</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Concurrency) -> dict:
+    out: dict = {}
+    if "reserved_concurrent_executions" in value:
+        out["ReservedConcurrentExecutions"] = value["reserved_concurrent_executions"]
+    return out
+
+
+def deserialize_json(data: dict) -> Concurrency:
+    out: Concurrency = {}  # type: ignore[typeddict-item]
+    if "ReservedConcurrentExecutions" in data:
+        out["reserved_concurrent_executions"] = data["ReservedConcurrentExecutions"]
+    return out

aws_sdk_lambda/types/context_details.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ContextDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.error_object
+    import aws_sdk_lambda.types.operation_payload
+    import aws_sdk_lambda.types.replay_children
+
+
+class ContextDetails(TypedDict):
+    replay_children: NotRequired["aws_sdk_lambda.types.replay_children.ReplayChildren"]
+    """<p>Whether the state data of child operations of this completed context should be included in the invoke payload and <code>GetDurableExecutionState</code> response.</p>"""
+    result: NotRequired["aws_sdk_lambda.types.operation_payload.OperationPayload"]
+    """<p>The response payload from the context.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.error_object.ErrorObject"]
+    """<p>Details about the context failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ContextDetails) -> dict:
+    out: dict = {}
+    if "replay_children" in value:
+        out["ReplayChildren"] = value["replay_children"]
+    if "result" in value:
+        out["Result"] = value["result"]
+    if "error" in value:
+        import aws_sdk_lambda.types.error_object
+
+        out["Error"] = aws_sdk_lambda.types.error_object.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> ContextDetails:
+    out: ContextDetails = {}  # type: ignore[typeddict-item]
+    if "ReplayChildren" in data:
+        out["replay_children"] = data["ReplayChildren"]
+    if "Result" in data:
+        out["result"] = data["Result"]
+    if "Error" in data:
+        import aws_sdk_lambda.types.error_object
+
+        out["error"] = aws_sdk_lambda.types.error_object.deserialize_json(data["Error"])
+    return out

aws_sdk_lambda/types/context_failed_details.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ContextFailedDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_error
+
+
+class ContextFailedDetails(TypedDict):
+    error: "aws_sdk_lambda.types.event_error.EventError"
+    """<p>Details about the context failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ContextFailedDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.event_error
+
+    out["Error"] = aws_sdk_lambda.types.event_error.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> ContextFailedDetails:
+    out: ContextFailedDetails = {}  # type: ignore[typeddict-item]
+    if "Error" in data:
+        import aws_sdk_lambda.types.event_error
+
+        out["error"] = aws_sdk_lambda.types.event_error.deserialize_json(data["Error"])
+    else:
+        raise DeserializationError("ContextFailedDetails.error required")
+    return out

aws_sdk_lambda/types/context_options.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ContextOptions``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.replay_children
+
+
+class ContextOptions(TypedDict):
+    replay_children: NotRequired["aws_sdk_lambda.types.replay_children.ReplayChildren"]
+    """<p>Whether the state data of children of the completed context should be included in the invoke payload and <code>GetDurableExecutionState</code> response.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ContextOptions) -> dict:
+    out: dict = {}
+    if "replay_children" in value:
+        out["ReplayChildren"] = value["replay_children"]
+    return out
+
+
+def deserialize_json(data: dict) -> ContextOptions:
+    out: ContextOptions = {}  # type: ignore[typeddict-item]
+    if "ReplayChildren" in data:
+        out["replay_children"] = data["ReplayChildren"]
+    return out

aws_sdk_lambda/types/context_started_details.py

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

aws_sdk_lambda/types/context_succeeded_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ContextSucceededDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_result
+
+
+class ContextSucceededDetails(TypedDict):
+    result: "aws_sdk_lambda.types.event_result.EventResult"
+    """<p>The JSON response payload from the successful context.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ContextSucceededDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.event_result
+
+    out["Result"] = aws_sdk_lambda.types.event_result.serialize_json(value["result"])
+    return out
+
+
+def deserialize_json(data: dict) -> ContextSucceededDetails:
+    out: ContextSucceededDetails = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        import aws_sdk_lambda.types.event_result
+
+        out["result"] = aws_sdk_lambda.types.event_result.deserialize_json(
+            data["Result"]
+        )
+    else:
+        raise DeserializationError("ContextSucceededDetails.result required")
+    return out

aws_sdk_lambda/types/cors.py

@@ -0,0 +1,100 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Cors``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.allow_credentials
+    import aws_sdk_lambda.types.allow_methods_list
+    import aws_sdk_lambda.types.allow_origins_list
+    import aws_sdk_lambda.types.headers_list
+    import aws_sdk_lambda.types.max_age
+
+
+class Cors(TypedDict):
+    allow_credentials: NotRequired[
+        "aws_sdk_lambda.types.allow_credentials.AllowCredentials"
+    ]
+    """<p>Whether to allow cookies or other credentials in requests to your function URL. The default is <code>false</code>.</p>"""
+    allow_headers: NotRequired["aws_sdk_lambda.types.headers_list.HeadersList"]
+    """<p>The HTTP headers that origins can include in requests to your function URL. For example: <code>Date</code>, <code>Keep-Alive</code>, <code>X-Custom-Header</code>.</p>"""
+    allow_methods: NotRequired[
+        "aws_sdk_lambda.types.allow_methods_list.AllowMethodsList"
+    ]
+    """<p>The HTTP methods that are allowed when calling your function URL. For example: <code>GET</code>, <code>POST</code>, <code>DELETE</code>, or the wildcard character (<code>*</code>).</p>"""
+    allow_origins: NotRequired[
+        "aws_sdk_lambda.types.allow_origins_list.AllowOriginsList"
+    ]
+    """<p>The origins that can access your function URL. You can list any number of specific origins, separated by a comma. For example: <code>https://www.example.com</code>, <code>http://localhost:60905</code>.</p> <p>Alternatively, you can grant access to all origins using the wildcard character (<code>*</code>).</p>"""
+    expose_headers: NotRequired["aws_sdk_lambda.types.headers_list.HeadersList"]
+    """<p>The HTTP headers in your function response that you want to expose to origins that call your function URL. For example: <code>Date</code>, <code>Keep-Alive</code>, <code>X-Custom-Header</code>.</p>"""
+    max_age: NotRequired["aws_sdk_lambda.types.max_age.MaxAge"]
+    """<p>The maximum amount of time, in seconds, that web browsers can cache results of a preflight request. By default, this is set to <code>0</code>, which means that the browser doesn't cache results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Cors) -> dict:
+    out: dict = {}
+    if "allow_credentials" in value:
+        out["AllowCredentials"] = value["allow_credentials"]
+    if "allow_headers" in value:
+        import aws_sdk_lambda.types.headers_list
+
+        out["AllowHeaders"] = aws_sdk_lambda.types.headers_list.serialize_json(
+            value["allow_headers"]
+        )
+    if "allow_methods" in value:
+        import aws_sdk_lambda.types.allow_methods_list
+
+        out["AllowMethods"] = aws_sdk_lambda.types.allow_methods_list.serialize_json(
+            value["allow_methods"]
+        )
+    if "allow_origins" in value:
+        import aws_sdk_lambda.types.allow_origins_list
+
+        out["AllowOrigins"] = aws_sdk_lambda.types.allow_origins_list.serialize_json(
+            value["allow_origins"]
+        )
+    if "expose_headers" in value:
+        import aws_sdk_lambda.types.headers_list
+
+        out["ExposeHeaders"] = aws_sdk_lambda.types.headers_list.serialize_json(
+            value["expose_headers"]
+        )
+    if "max_age" in value:
+        out["MaxAge"] = value["max_age"]
+    return out
+
+
+def deserialize_json(data: dict) -> Cors:
+    out: Cors = {}  # type: ignore[typeddict-item]
+    if "AllowCredentials" in data:
+        out["allow_credentials"] = data["AllowCredentials"]
+    if "AllowHeaders" in data:
+        import aws_sdk_lambda.types.headers_list
+
+        out["allow_headers"] = aws_sdk_lambda.types.headers_list.deserialize_json(
+            data["AllowHeaders"]
+        )
+    if "AllowMethods" in data:
+        import aws_sdk_lambda.types.allow_methods_list
+
+        out["allow_methods"] = aws_sdk_lambda.types.allow_methods_list.deserialize_json(
+            data["AllowMethods"]
+        )
+    if "AllowOrigins" in data:
+        import aws_sdk_lambda.types.allow_origins_list
+
+        out["allow_origins"] = aws_sdk_lambda.types.allow_origins_list.deserialize_json(
+            data["AllowOrigins"]
+        )
+    if "ExposeHeaders" in data:
+        import aws_sdk_lambda.types.headers_list
+
+        out["expose_headers"] = aws_sdk_lambda.types.headers_list.deserialize_json(
+            data["ExposeHeaders"]
+        )
+    if "MaxAge" in data:
+        out["max_age"] = data["MaxAge"]
+    return out

aws_sdk_lambda/types/create_alias_request.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CreateAliasRequest``."""
+
+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.alias
+    import aws_sdk_lambda.types.alias_routing_configuration
+    import aws_sdk_lambda.types.description
+    import aws_sdk_lambda.types.function_name
+    import aws_sdk_lambda.types.version_with_latest_published
+
+
+class CreateAliasRequest(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>"""
+    function_version: (
+        "aws_sdk_lambda.types.version_with_latest_published.VersionWithLatestPublished"
+    )
+    """<p>The function version that the alias invokes.</p>"""
+    description: NotRequired["aws_sdk_lambda.types.description.Description"]
+    """<p>A description of the alias.</p>"""
+    routing_config: NotRequired[
+        "aws_sdk_lambda.types.alias_routing_configuration.AliasRoutingConfiguration"
+    ]
+    """<p>The <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/configuration-aliases.html#configuring-alias-routing\">routing configuration</a> of the alias.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateAliasRequest) -> dict:
+    out: dict = {}
+    out["Name"] = value["name"]
+    out["FunctionVersion"] = value["function_version"]
+    if "description" in value:
+        out["Description"] = value["description"]
+    if "routing_config" in value:
+        import aws_sdk_lambda.types.alias_routing_configuration
+
+        out["RoutingConfig"] = (
+            aws_sdk_lambda.types.alias_routing_configuration.serialize_json(
+                value["routing_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> CreateAliasRequest:
+    out: CreateAliasRequest = {}  # type: ignore[typeddict-item]
+    if "Name" in data:
+        out["name"] = data["Name"]
+    else:
+        raise DeserializationError("CreateAliasRequest.name required")
+    if "FunctionVersion" in data:
+        out["function_version"] = data["FunctionVersion"]
+    else:
+        raise DeserializationError("CreateAliasRequest.function_version required")
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "RoutingConfig" in data:
+        import aws_sdk_lambda.types.alias_routing_configuration
+
+        out["routing_config"] = (
+            aws_sdk_lambda.types.alias_routing_configuration.deserialize_json(
+                data["RoutingConfig"]
+            )
+        )
+    return out

aws_sdk_lambda/types/create_capacity_provider_request.py

@@ -0,0 +1,139 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CreateCapacityProviderRequest``."""
+
+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.capacity_provider_name
+    import aws_sdk_lambda.types.capacity_provider_permissions_config
+    import aws_sdk_lambda.types.capacity_provider_scaling_config
+    import aws_sdk_lambda.types.capacity_provider_vpc_config
+    import aws_sdk_lambda.types.instance_requirements
+    import aws_sdk_lambda.types.kms_key_arn_non_empty
+    import aws_sdk_lambda.types.tags
+
+
+class CreateCapacityProviderRequest(TypedDict):
+    capacity_provider_name: (
+        "aws_sdk_lambda.types.capacity_provider_name.CapacityProviderName"
+    )
+    """<p>The name of the capacity provider. </p>"""
+    vpc_config: (
+        "aws_sdk_lambda.types.capacity_provider_vpc_config.CapacityProviderVpcConfig"
+    )
+    """<p>The VPC configuration for the capacity provider, including subnet IDs and security group IDs where compute instances will be launched.</p>"""
+    permissions_config: "aws_sdk_lambda.types.capacity_provider_permissions_config.CapacityProviderPermissionsConfig"
+    """<p>The permissions configuration that specifies the IAM role ARN used by the capacity provider to manage compute resources.</p>"""
+    instance_requirements: NotRequired[
+        "aws_sdk_lambda.types.instance_requirements.InstanceRequirements"
+    ]
+    """<p>The instance requirements that specify the compute instance characteristics, including architectures and allowed or excluded instance types.</p>"""
+    capacity_provider_scaling_config: NotRequired[
+        "aws_sdk_lambda.types.capacity_provider_scaling_config.CapacityProviderScalingConfig"
+    ]
+    """<p>The scaling configuration that defines how the capacity provider scales compute instances, including maximum vCPU count and scaling policies.</p>"""
+    kms_key_arn: NotRequired[
+        "aws_sdk_lambda.types.kms_key_arn_non_empty.KMSKeyArnNonEmpty"
+    ]
+    """<p>The ARN of the KMS key used to encrypt data associated with the capacity provider.</p>"""
+    tags: NotRequired["aws_sdk_lambda.types.tags.Tags"]
+    """<p>A list of tags to associate with the capacity provider.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateCapacityProviderRequest) -> dict:
+    out: dict = {}
+    out["CapacityProviderName"] = value["capacity_provider_name"]
+    import aws_sdk_lambda.types.capacity_provider_vpc_config
+
+    out["VpcConfig"] = aws_sdk_lambda.types.capacity_provider_vpc_config.serialize_json(
+        value["vpc_config"]
+    )
+    import aws_sdk_lambda.types.capacity_provider_permissions_config
+
+    out["PermissionsConfig"] = (
+        aws_sdk_lambda.types.capacity_provider_permissions_config.serialize_json(
+            value["permissions_config"]
+        )
+    )
+    if "instance_requirements" in value:
+        import aws_sdk_lambda.types.instance_requirements
+
+        out["InstanceRequirements"] = (
+            aws_sdk_lambda.types.instance_requirements.serialize_json(
+                value["instance_requirements"]
+            )
+        )
+    if "capacity_provider_scaling_config" in value:
+        import aws_sdk_lambda.types.capacity_provider_scaling_config
+
+        out["CapacityProviderScalingConfig"] = (
+            aws_sdk_lambda.types.capacity_provider_scaling_config.serialize_json(
+                value["capacity_provider_scaling_config"]
+            )
+        )
+    if "kms_key_arn" in value:
+        out["KmsKeyArn"] = value["kms_key_arn"]
+    if "tags" in value:
+        import aws_sdk_lambda.types.tags
+
+        out["Tags"] = aws_sdk_lambda.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> CreateCapacityProviderRequest:
+    out: CreateCapacityProviderRequest = {}  # type: ignore[typeddict-item]
+    if "CapacityProviderName" in data:
+        out["capacity_provider_name"] = data["CapacityProviderName"]
+    else:
+        raise DeserializationError(
+            "CreateCapacityProviderRequest.capacity_provider_name required"
+        )
+    if "VpcConfig" in data:
+        import aws_sdk_lambda.types.capacity_provider_vpc_config
+
+        out["vpc_config"] = (
+            aws_sdk_lambda.types.capacity_provider_vpc_config.deserialize_json(
+                data["VpcConfig"]
+            )
+        )
+    else:
+        raise DeserializationError("CreateCapacityProviderRequest.vpc_config required")
+    if "PermissionsConfig" in data:
+        import aws_sdk_lambda.types.capacity_provider_permissions_config
+
+        out["permissions_config"] = (
+            aws_sdk_lambda.types.capacity_provider_permissions_config.deserialize_json(
+                data["PermissionsConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CreateCapacityProviderRequest.permissions_config required"
+        )
+    if "InstanceRequirements" in data:
+        import aws_sdk_lambda.types.instance_requirements
+
+        out["instance_requirements"] = (
+            aws_sdk_lambda.types.instance_requirements.deserialize_json(
+                data["InstanceRequirements"]
+            )
+        )
+    if "CapacityProviderScalingConfig" in data:
+        import aws_sdk_lambda.types.capacity_provider_scaling_config
+
+        out["capacity_provider_scaling_config"] = (
+            aws_sdk_lambda.types.capacity_provider_scaling_config.deserialize_json(
+                data["CapacityProviderScalingConfig"]
+            )
+        )
+    if "KmsKeyArn" in data:
+        out["kms_key_arn"] = data["KmsKeyArn"]
+    if "Tags" in data:
+        import aws_sdk_lambda.types.tags
+
+        out["tags"] = aws_sdk_lambda.types.tags.deserialize_json(data["Tags"])
+    return out

aws_sdk_lambda/types/create_capacity_provider_response.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CreateCapacityProviderResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.capacity_provider
+
+
+class CreateCapacityProviderResponse(TypedDict):
+    capacity_provider: "aws_sdk_lambda.types.capacity_provider.CapacityProvider"
+    """<p>Information about the capacity provider that was created.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CreateCapacityProviderResponse) -> 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) -> CreateCapacityProviderResponse:
+    out: CreateCapacityProviderResponse = {}  # 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(
+            "CreateCapacityProviderResponse.capacity_provider required"
+        )
+    return out