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

aws_sdk_lambda/types/send_durable_execution_callback_success_request.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackSuccessRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.binary_operation_payload
+    import aws_sdk_lambda.types.callback_id
+
+
+class SendDurableExecutionCallbackSuccessRequest(TypedDict):
+    callback_id: "aws_sdk_lambda.types.callback_id.CallbackId"
+    """<p>The unique identifier for the callback operation.</p>"""
+    result: NotRequired[
+        "aws_sdk_lambda.types.binary_operation_payload.BinaryOperationPayload"
+    ]
+    """<p>The result data from the successful callback operation. Maximum size is 256 KB.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackSuccessRequest) -> dict:
+    out: dict = {}
+    if "result" in value:
+        import aws_sdk_lambda.types.binary_operation_payload
+
+        out["Result"] = aws_sdk_lambda.types.binary_operation_payload.serialize_json(
+            value["result"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackSuccessRequest:
+    out: SendDurableExecutionCallbackSuccessRequest = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        import aws_sdk_lambda.types.binary_operation_payload
+
+        out["result"] = aws_sdk_lambda.types.binary_operation_payload.deserialize_json(
+            data["Result"]
+        )
+    return out

aws_sdk_lambda/types/send_durable_execution_callback_success_response.py

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

aws_sdk_lambda/types/sensitive_string.py

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

aws_sdk_lambda/types/signing_profile_version_arns.py

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

aws_sdk_lambda/types/snap_start.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SnapStart``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.snap_start_apply_on
+
+
+class SnapStart(TypedDict):
+    apply_on: NotRequired["aws_sdk_lambda.types.snap_start_apply_on.SnapStartApplyOn"]
+    """<p>Set to <code>PublishedVersions</code> to create a snapshot of the initialized execution environment when you publish a function version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SnapStart) -> dict:
+    out: dict = {}
+    if "apply_on" in value:
+        import aws_sdk_lambda.types.snap_start_apply_on
+
+        out["ApplyOn"] = aws_sdk_lambda.types.snap_start_apply_on.serialize_json(
+            value["apply_on"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SnapStart:
+    out: SnapStart = {}  # type: ignore[typeddict-item]
+    if "ApplyOn" in data:
+        import aws_sdk_lambda.types.snap_start_apply_on
+
+        out["apply_on"] = aws_sdk_lambda.types.snap_start_apply_on.deserialize_json(
+            data["ApplyOn"]
+        )
+    return out

aws_sdk_lambda/types/snap_start_apply_on.py

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

aws_sdk_lambda/types/snap_start_optimization_status.py

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

aws_sdk_lambda/types/snap_start_response.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SnapStartResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.snap_start_apply_on
+    import aws_sdk_lambda.types.snap_start_optimization_status
+
+
+class SnapStartResponse(TypedDict):
+    apply_on: NotRequired["aws_sdk_lambda.types.snap_start_apply_on.SnapStartApplyOn"]
+    """<p>When set to <code>PublishedVersions</code>, Lambda creates a snapshot of the execution environment when you publish a function version.</p>"""
+    optimization_status: NotRequired[
+        "aws_sdk_lambda.types.snap_start_optimization_status.SnapStartOptimizationStatus"
+    ]
+    """<p>When you provide a <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html#versioning-versions-using\">qualified Amazon Resource Name (ARN)</a>, this response element indicates whether SnapStart is activated for the specified function version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SnapStartResponse) -> dict:
+    out: dict = {}
+    if "apply_on" in value:
+        import aws_sdk_lambda.types.snap_start_apply_on
+
+        out["ApplyOn"] = aws_sdk_lambda.types.snap_start_apply_on.serialize_json(
+            value["apply_on"]
+        )
+    if "optimization_status" in value:
+        import aws_sdk_lambda.types.snap_start_optimization_status
+
+        out["OptimizationStatus"] = (
+            aws_sdk_lambda.types.snap_start_optimization_status.serialize_json(
+                value["optimization_status"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SnapStartResponse:
+    out: SnapStartResponse = {}  # type: ignore[typeddict-item]
+    if "ApplyOn" in data:
+        import aws_sdk_lambda.types.snap_start_apply_on
+
+        out["apply_on"] = aws_sdk_lambda.types.snap_start_apply_on.deserialize_json(
+            data["ApplyOn"]
+        )
+    if "OptimizationStatus" in data:
+        import aws_sdk_lambda.types.snap_start_optimization_status
+
+        out["optimization_status"] = (
+            aws_sdk_lambda.types.snap_start_optimization_status.deserialize_json(
+                data["OptimizationStatus"]
+            )
+        )
+    return out

aws_sdk_lambda/types/source_access_configuration.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SourceAccessConfiguration``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.source_access_type
+    import aws_sdk_lambda.types.uri
+
+
+class SourceAccessConfiguration(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.source_access_type.SourceAccessType"]
+    """<p>The type of authentication protocol, VPC components, or virtual host for your event source. For example: <code>\"Type\":\"SASL_SCRAM_512_AUTH\"</code>.</p> <ul> <li> <p> <code>BASIC_AUTH</code> – (Amazon MQ) The Secrets Manager secret that stores your broker credentials.</p> </li> <li> <p> <code>BASIC_AUTH</code> – (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL/PLAIN authentication of your Apache Kafka brokers.</p> </li> <li> <p> <code>VPC_SUBNET</code> – (Self-managed Apache Kafka) The subnets associated with your VPC. Lambda connects to these subnets to fetch data from your self-managed Apache Kafka cluster.</p> </li> <li> <p> <code>VPC_SECURITY_GROUP</code> – (Self-managed Apache Kafka) The VPC security group used to manage access to your self-managed Apache Kafka brokers.</p> </li> <li> <p> <code>SASL_SCRAM_256_AUTH</code> – (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL SCRAM-256 authentication of your self-managed Apache Kafka brokers.</p> </li> <li> <p> <code>SASL_SCRAM_512_AUTH</code> – (Amazon MSK, Self-managed Apache Kafka) The Secrets Manager ARN of your secret key used for SASL SCRAM-512 authentication of your self-managed Apache Kafka brokers.</p> </li> <li> <p> <code>VIRTUAL_HOST</code> –- (RabbitMQ) The name of the virtual host in your RabbitMQ broker. Lambda uses this RabbitMQ host as the event source. This property cannot be specified in an UpdateEventSourceMapping API call.</p> </li> <li> <p> <code>CLIENT_CERTIFICATE_TLS_AUTH</code> – (Amazon MSK, self-managed Apache Kafka) The Secrets Manager ARN of your secret key containing the certificate chain (X.509 PEM), private key (PKCS#8 PEM), and private key password (optional) used for mutual TLS authentication of your MSK/Apache Kafka brokers.</p> </li> <li> <p> <code>SERVER_ROOT_CA_CERTIFICATE</code> – (Self-managed Apache Kafka) The Secrets Manager ARN of your secret key containing the root CA certificate (X.509 PEM) used for TLS encryption of your Apache Kafka brokers. </p> </li> </ul>"""
+    uri: NotRequired["aws_sdk_lambda.types.uri.URI"]
+    """<p>The value for your chosen configuration in <code>Type</code>. For example: <code>\"URI\": \"arn:aws:secretsmanager:us-east-1:01234567890:secret:MyBrokerSecretName\"</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SourceAccessConfiguration) -> dict:
+    out: dict = {}
+    if "type" in value:
+        import aws_sdk_lambda.types.source_access_type
+
+        out["Type"] = aws_sdk_lambda.types.source_access_type.serialize_json(
+            value["type"]
+        )
+    if "uri" in value:
+        out["URI"] = value["uri"]
+    return out
+
+
+def deserialize_json(data: dict) -> SourceAccessConfiguration:
+    out: SourceAccessConfiguration = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        import aws_sdk_lambda.types.source_access_type
+
+        out["type"] = aws_sdk_lambda.types.source_access_type.deserialize_json(
+            data["Type"]
+        )
+    if "URI" in data:
+        out["uri"] = data["URI"]
+    return out

aws_sdk_lambda/types/source_access_configurations.py

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

aws_sdk_lambda/types/source_access_type.py

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

aws_sdk_lambda/types/source_owner.py

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

aws_sdk_lambda/types/stack_trace_entries.py

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

aws_sdk_lambda/types/stack_trace_entry.py

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

aws_sdk_lambda/types/state.py

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

aws_sdk_lambda/types/state_reason.py

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

aws_sdk_lambda/types/state_reason_code.py

@@ -0,0 +1,101 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StateReasonCode``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+StateReasonCode: TypeAlias = Literal[
+    "Idle",
+    "Creating",
+    "Restoring",
+    "EniLimitExceeded",
+    "InsufficientRolePermissions",
+    "InvalidConfiguration",
+    "InternalError",
+    "SubnetOutOfIPAddresses",
+    "InvalidSubnet",
+    "InvalidSecurityGroup",
+    "ImageDeleted",
+    "ImageAccessDenied",
+    "InvalidImage",
+    "KMSKeyAccessDenied",
+    "KMSKeyNotFound",
+    "InvalidStateKMSKey",
+    "DisabledKMSKey",
+    "EFSIOError",
+    "EFSMountConnectivityError",
+    "EFSMountFailure",
+    "EFSMountTimeout",
+    "InvalidRuntime",
+    "InvalidZipFileException",
+    "FunctionError",
+    "DrainingDurableExecutions",
+    "VcpuLimitExceeded",
+    "CapacityProviderScalingLimitExceeded",
+    "InsufficientCapacity",
+    "EC2RequestLimitExceeded",
+    "FunctionError.InitTimeout",
+    "FunctionError.RuntimeInitError",
+    "FunctionError.ExtensionInitError",
+    "FunctionError.InvalidEntryPoint",
+    "FunctionError.InvalidWorkingDirectory",
+    "FunctionError.PermissionDenied",
+    "FunctionError.TooManyExtensions",
+    "FunctionError.InitResourceExhausted",
+    "DisallowedByVpcEncryptionControl",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "Idle",
+        "Creating",
+        "Restoring",
+        "EniLimitExceeded",
+        "InsufficientRolePermissions",
+        "InvalidConfiguration",
+        "InternalError",
+        "SubnetOutOfIPAddresses",
+        "InvalidSubnet",
+        "InvalidSecurityGroup",
+        "ImageDeleted",
+        "ImageAccessDenied",
+        "InvalidImage",
+        "KMSKeyAccessDenied",
+        "KMSKeyNotFound",
+        "InvalidStateKMSKey",
+        "DisabledKMSKey",
+        "EFSIOError",
+        "EFSMountConnectivityError",
+        "EFSMountFailure",
+        "EFSMountTimeout",
+        "InvalidRuntime",
+        "InvalidZipFileException",
+        "FunctionError",
+        "DrainingDurableExecutions",
+        "VcpuLimitExceeded",
+        "CapacityProviderScalingLimitExceeded",
+        "InsufficientCapacity",
+        "EC2RequestLimitExceeded",
+        "FunctionError.InitTimeout",
+        "FunctionError.RuntimeInitError",
+        "FunctionError.ExtensionInitError",
+        "FunctionError.InvalidEntryPoint",
+        "FunctionError.InvalidWorkingDirectory",
+        "FunctionError.PermissionDenied",
+        "FunctionError.TooManyExtensions",
+        "FunctionError.InitResourceExhausted",
+        "DisallowedByVpcEncryptionControl",
+    )
+)
+
+
+def serialize_json(value: StateReasonCode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> StateReasonCode:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown StateReasonCode value: {data!r}")
+    return cast(StateReasonCode, data)

aws_sdk_lambda/types/statement_id.py

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

aws_sdk_lambda/types/step_details.py

@@ -0,0 +1,68 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.attempt_count
+    import aws_sdk_lambda.types.error_object
+    import aws_sdk_lambda.types.execution_timestamp
+    import aws_sdk_lambda.types.operation_payload
+
+
+class StepDetails(TypedDict):
+    attempt: "aws_sdk_lambda.types.attempt_count.AttemptCount"
+    """<p>The current attempt number for this step.</p>"""
+    next_attempt_timestamp: NotRequired[
+        "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    """<p>The date and time when the next attempt is scheduled, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD). Only populated when the step is in a pending state.</p>"""
+    result: NotRequired["aws_sdk_lambda.types.operation_payload.OperationPayload"]
+    """<p>The JSON response payload from the step operation.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.error_object.ErrorObject"]
+    """<p>Details about the step failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepDetails) -> dict:
+    out: dict = {}
+    out["Attempt"] = value.get("attempt", 0)
+    if "next_attempt_timestamp" in value:
+        import aws_sdk_lambda.types.execution_timestamp
+
+        out["NextAttemptTimestamp"] = (
+            aws_sdk_lambda.types.execution_timestamp.serialize_json(
+                value["next_attempt_timestamp"]
+            )
+        )
+    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) -> StepDetails:
+    out: StepDetails = {}  # type: ignore[typeddict-item]
+    if "Attempt" in data:
+        out["attempt"] = data["Attempt"]
+    else:
+        out["attempt"] = 0
+    if "NextAttemptTimestamp" in data:
+        import aws_sdk_lambda.types.execution_timestamp
+
+        out["next_attempt_timestamp"] = (
+            aws_sdk_lambda.types.execution_timestamp.deserialize_json(
+                data["NextAttemptTimestamp"]
+            )
+        )
+    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/step_failed_details.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#StepFailedDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_error
+    import aws_sdk_lambda.types.retry_details
+
+
+class StepFailedDetails(TypedDict):
+    error: "aws_sdk_lambda.types.event_error.EventError"
+    """<p>Details about the step failure.</p>"""
+    retry_details: "aws_sdk_lambda.types.retry_details.RetryDetails"
+    """<p>Information about retry attempts for this step operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: StepFailedDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.event_error
+
+    out["Error"] = aws_sdk_lambda.types.event_error.serialize_json(value["error"])
+    import aws_sdk_lambda.types.retry_details
+
+    out["RetryDetails"] = aws_sdk_lambda.types.retry_details.serialize_json(
+        value["retry_details"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> StepFailedDetails:
+    out: StepFailedDetails = {}  # 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("StepFailedDetails.error required")
+    if "RetryDetails" in data:
+        import aws_sdk_lambda.types.retry_details
+
+        out["retry_details"] = aws_sdk_lambda.types.retry_details.deserialize_json(
+            data["RetryDetails"]
+        )
+    else:
+        raise DeserializationError("StepFailedDetails.retry_details required")
+    return out