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

aws_sdk_lambda/types/get_policy_response.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetPolicyResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class GetPolicyResponse(TypedDict):
+    policy: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The resource-based policy.</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: GetPolicyResponse) -> 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) -> GetPolicyResponse:
+    out: GetPolicyResponse = {}  # 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_provisioned_concurrency_config_request.py

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

aws_sdk_lambda/types/get_provisioned_concurrency_config_response.py

@@ -0,0 +1,94 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetProvisionedConcurrencyConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    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 GetProvisionedConcurrencyConfigResponse(TypedDict):
+    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: GetProvisionedConcurrencyConfigResponse) -> dict:
+    out: dict = {}
+    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) -> GetProvisionedConcurrencyConfigResponse:
+    out: GetProvisionedConcurrencyConfigResponse = {}  # type: ignore[typeddict-item]
+    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/get_runtime_management_config_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetRuntimeManagementConfigRequest``."""
+
+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 GetRuntimeManagementConfigRequest(TypedDict):
+    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>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.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version of the function. This can be <code>$LATEST</code> or a published version number. If no value is specified, the configuration for the <code>$LATEST</code> version is returned.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetRuntimeManagementConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetRuntimeManagementConfigRequest:
+    out: GetRuntimeManagementConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_runtime_management_config_response.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetRuntimeManagementConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.name_spaced_function_arn
+    import aws_sdk_lambda.types.runtime_version_arn
+    import aws_sdk_lambda.types.update_runtime_on
+
+
+class GetRuntimeManagementConfigResponse(TypedDict):
+    update_runtime_on: NotRequired[
+        "aws_sdk_lambda.types.update_runtime_on.UpdateRuntimeOn"
+    ]
+    """<p>The current runtime update mode of the function.</p>"""
+    runtime_version_arn: NotRequired[
+        "aws_sdk_lambda.types.runtime_version_arn.RuntimeVersionArn"
+    ]
+    """<p>The ARN of the runtime the function is configured to use. If the runtime update mode is <b>Manual</b>, the ARN is returned, otherwise <code>null</code> is returned.</p>"""
+    function_arn: NotRequired[
+        "aws_sdk_lambda.types.name_spaced_function_arn.NameSpacedFunctionArn"
+    ]
+    """<p>The Amazon Resource Name (ARN) of your function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetRuntimeManagementConfigResponse) -> dict:
+    out: dict = {}
+    if "update_runtime_on" in value:
+        import aws_sdk_lambda.types.update_runtime_on
+
+        out["UpdateRuntimeOn"] = aws_sdk_lambda.types.update_runtime_on.serialize_json(
+            value["update_runtime_on"]
+        )
+    if "runtime_version_arn" in value:
+        out["RuntimeVersionArn"] = value["runtime_version_arn"]
+    if "function_arn" in value:
+        out["FunctionArn"] = value["function_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetRuntimeManagementConfigResponse:
+    out: GetRuntimeManagementConfigResponse = {}  # type: ignore[typeddict-item]
+    if "UpdateRuntimeOn" in data:
+        import aws_sdk_lambda.types.update_runtime_on
+
+        out["update_runtime_on"] = (
+            aws_sdk_lambda.types.update_runtime_on.deserialize_json(
+                data["UpdateRuntimeOn"]
+            )
+        )
+    if "RuntimeVersionArn" in data:
+        out["runtime_version_arn"] = data["RuntimeVersionArn"]
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    return out

aws_sdk_lambda/types/handler.py

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

aws_sdk_lambda/types/header.py

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

aws_sdk_lambda/types/headers_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#HeadersList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.header
+
+HeadersList: TypeAlias = list["aws_sdk_lambda.types.header.Header"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: HeadersList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> HeadersList:
+    return list(data)

aws_sdk_lambda/types/http_status.py

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

aws_sdk_lambda/types/image_config.py

@@ -0,0 +1,59 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ImageConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string_list
+    import aws_sdk_lambda.types.working_directory
+
+
+class ImageConfig(TypedDict):
+    entry_point: NotRequired["aws_sdk_lambda.types.string_list.StringList"]
+    """<p>Specifies the entry point to their application, which is typically the location of the runtime executable.</p>"""
+    command: NotRequired["aws_sdk_lambda.types.string_list.StringList"]
+    """<p>Specifies parameters that you want to pass in with ENTRYPOINT.</p>"""
+    working_directory: NotRequired[
+        "aws_sdk_lambda.types.working_directory.WorkingDirectory"
+    ]
+    """<p>Specifies the working directory.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ImageConfig) -> dict:
+    out: dict = {}
+    if "entry_point" in value:
+        import aws_sdk_lambda.types.string_list
+
+        out["EntryPoint"] = aws_sdk_lambda.types.string_list.serialize_json(
+            value["entry_point"]
+        )
+    if "command" in value:
+        import aws_sdk_lambda.types.string_list
+
+        out["Command"] = aws_sdk_lambda.types.string_list.serialize_json(
+            value["command"]
+        )
+    if "working_directory" in value:
+        out["WorkingDirectory"] = value["working_directory"]
+    return out
+
+
+def deserialize_json(data: dict) -> ImageConfig:
+    out: ImageConfig = {}  # type: ignore[typeddict-item]
+    if "EntryPoint" in data:
+        import aws_sdk_lambda.types.string_list
+
+        out["entry_point"] = aws_sdk_lambda.types.string_list.deserialize_json(
+            data["EntryPoint"]
+        )
+    if "Command" in data:
+        import aws_sdk_lambda.types.string_list
+
+        out["command"] = aws_sdk_lambda.types.string_list.deserialize_json(
+            data["Command"]
+        )
+    if "WorkingDirectory" in data:
+        out["working_directory"] = data["WorkingDirectory"]
+    return out

aws_sdk_lambda/types/image_config_error.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ImageConfigError``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.sensitive_string
+    import aws_sdk_lambda.types.string
+
+
+class ImageConfigError(TypedDict):
+    error_code: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>Error code.</p>"""
+    message: NotRequired["aws_sdk_lambda.types.sensitive_string.SensitiveString"]
+    """<p>Error message.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ImageConfigError) -> dict:
+    out: dict = {}
+    if "error_code" in value:
+        out["ErrorCode"] = value["error_code"]
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> ImageConfigError:
+    out: ImageConfigError = {}  # type: ignore[typeddict-item]
+    if "ErrorCode" in data:
+        out["error_code"] = data["ErrorCode"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out

aws_sdk_lambda/types/image_config_response.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ImageConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.image_config
+    import aws_sdk_lambda.types.image_config_error
+
+
+class ImageConfigResponse(TypedDict):
+    image_config: NotRequired["aws_sdk_lambda.types.image_config.ImageConfig"]
+    """<p>Configuration values that override the container image Dockerfile.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.image_config_error.ImageConfigError"]
+    """<p>Error response to <code>GetFunctionConfiguration</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ImageConfigResponse) -> dict:
+    out: dict = {}
+    if "image_config" in value:
+        import aws_sdk_lambda.types.image_config
+
+        out["ImageConfig"] = aws_sdk_lambda.types.image_config.serialize_json(
+            value["image_config"]
+        )
+    if "error" in value:
+        import aws_sdk_lambda.types.image_config_error
+
+        out["Error"] = aws_sdk_lambda.types.image_config_error.serialize_json(
+            value["error"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ImageConfigResponse:
+    out: ImageConfigResponse = {}  # type: ignore[typeddict-item]
+    if "ImageConfig" in data:
+        import aws_sdk_lambda.types.image_config
+
+        out["image_config"] = aws_sdk_lambda.types.image_config.deserialize_json(
+            data["ImageConfig"]
+        )
+    if "Error" in data:
+        import aws_sdk_lambda.types.image_config_error
+
+        out["error"] = aws_sdk_lambda.types.image_config_error.deserialize_json(
+            data["Error"]
+        )
+    return out

aws_sdk_lambda/types/include_execution_data.py

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

aws_sdk_lambda/types/input_payload.py

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

aws_sdk_lambda/types/instance_requirements.py

@@ -0,0 +1,79 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InstanceRequirements``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.architectures_list
+    import aws_sdk_lambda.types.instance_type_set
+
+
+class InstanceRequirements(TypedDict):
+    architectures: NotRequired[
+        "aws_sdk_lambda.types.architectures_list.ArchitecturesList"
+    ]
+    """<p>A list of supported CPU architectures for compute instances. Valid values include <code>x86_64</code> and <code>arm64</code>.</p>"""
+    allowed_instance_types: NotRequired[
+        "aws_sdk_lambda.types.instance_type_set.InstanceTypeSet"
+    ]
+    """<p>A list of EC2 instance types that the capacity provider is allowed to use. If not specified, all compatible instance types are allowed.</p>"""
+    excluded_instance_types: NotRequired[
+        "aws_sdk_lambda.types.instance_type_set.InstanceTypeSet"
+    ]
+    """<p>A list of EC2 instance types that the capacity provider should not use, even if they meet other requirements.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InstanceRequirements) -> dict:
+    out: dict = {}
+    if "architectures" in value:
+        import aws_sdk_lambda.types.architectures_list
+
+        out["Architectures"] = aws_sdk_lambda.types.architectures_list.serialize_json(
+            value["architectures"]
+        )
+    if "allowed_instance_types" in value:
+        import aws_sdk_lambda.types.instance_type_set
+
+        out["AllowedInstanceTypes"] = (
+            aws_sdk_lambda.types.instance_type_set.serialize_json(
+                value["allowed_instance_types"]
+            )
+        )
+    if "excluded_instance_types" in value:
+        import aws_sdk_lambda.types.instance_type_set
+
+        out["ExcludedInstanceTypes"] = (
+            aws_sdk_lambda.types.instance_type_set.serialize_json(
+                value["excluded_instance_types"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> InstanceRequirements:
+    out: InstanceRequirements = {}  # type: ignore[typeddict-item]
+    if "Architectures" in data:
+        import aws_sdk_lambda.types.architectures_list
+
+        out["architectures"] = aws_sdk_lambda.types.architectures_list.deserialize_json(
+            data["Architectures"]
+        )
+    if "AllowedInstanceTypes" in data:
+        import aws_sdk_lambda.types.instance_type_set
+
+        out["allowed_instance_types"] = (
+            aws_sdk_lambda.types.instance_type_set.deserialize_json(
+                data["AllowedInstanceTypes"]
+            )
+        )
+    if "ExcludedInstanceTypes" in data:
+        import aws_sdk_lambda.types.instance_type_set
+
+        out["excluded_instance_types"] = (
+            aws_sdk_lambda.types.instance_type_set.deserialize_json(
+                data["ExcludedInstanceTypes"]
+            )
+        )
+    return out

aws_sdk_lambda/types/instance_type.py

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

aws_sdk_lambda/types/instance_type_set.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InstanceTypeSet``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.instance_type
+
+InstanceTypeSet: TypeAlias = list["aws_sdk_lambda.types.instance_type.InstanceType"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InstanceTypeSet) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> InstanceTypeSet:
+    return list(data)

aws_sdk_lambda/types/integer.py

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

aws_sdk_lambda/types/invocation_completed_details.py

@@ -0,0 +1,79 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvocationCompletedDetails``."""
+
+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.event_error
+    import aws_sdk_lambda.types.execution_timestamp
+    import aws_sdk_lambda.types.string
+
+
+class InvocationCompletedDetails(TypedDict):
+    start_timestamp: "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    """<p>The date and time when the invocation started, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    end_timestamp: "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    """<p>The date and time when the invocation ended, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    request_id: "aws_sdk_lambda.types.string.String"
+    """<p>The request ID for the invocation.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.event_error.EventError"]
+    """<p>Details about the invocation failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvocationCompletedDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.execution_timestamp
+
+    out["StartTimestamp"] = aws_sdk_lambda.types.execution_timestamp.serialize_json(
+        value["start_timestamp"]
+    )
+    import aws_sdk_lambda.types.execution_timestamp
+
+    out["EndTimestamp"] = aws_sdk_lambda.types.execution_timestamp.serialize_json(
+        value["end_timestamp"]
+    )
+    out["RequestId"] = value["request_id"]
+    if "error" in value:
+        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) -> InvocationCompletedDetails:
+    out: InvocationCompletedDetails = {}  # type: ignore[typeddict-item]
+    if "StartTimestamp" in data:
+        import aws_sdk_lambda.types.execution_timestamp
+
+        out["start_timestamp"] = (
+            aws_sdk_lambda.types.execution_timestamp.deserialize_json(
+                data["StartTimestamp"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "InvocationCompletedDetails.start_timestamp required"
+        )
+    if "EndTimestamp" in data:
+        import aws_sdk_lambda.types.execution_timestamp
+
+        out["end_timestamp"] = (
+            aws_sdk_lambda.types.execution_timestamp.deserialize_json(
+                data["EndTimestamp"]
+            )
+        )
+    else:
+        raise DeserializationError("InvocationCompletedDetails.end_timestamp required")
+    if "RequestId" in data:
+        out["request_id"] = data["RequestId"]
+    else:
+        raise DeserializationError("InvocationCompletedDetails.request_id required")
+    if "Error" in data:
+        import aws_sdk_lambda.types.event_error
+
+        out["error"] = aws_sdk_lambda.types.event_error.deserialize_json(data["Error"])
+    return out