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

aws_sdk_lambda/types/remove_permission_request.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RemovePermissionRequest``."""
+
+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.namespaced_statement_id
+    import aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier
+    import aws_sdk_lambda.types.string
+
+
+class RemovePermissionRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    )
+    """<p>The name or ARN of the Lambda function, version, or alias.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code> (name-only), <code>my-function:v1</code> (with alias).</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>You can append a version number or alias to any of the formats. The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    statement_id: "aws_sdk_lambda.types.namespaced_statement_id.NamespacedStatementId"
+    """<p>Statement ID of the permission to remove.</p>"""
+    qualifier: NotRequired[
+        "aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version or alias to remove permissions from a published version of the function.</p>"""
+    revision_id: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>Update the policy only if the revision ID matches the ID that's specified. Use this option to avoid modifying a policy that has changed since you last read it.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RemovePermissionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> RemovePermissionRequest:
+    out: RemovePermissionRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/replay_children.py

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

aws_sdk_lambda/types/reserved_concurrent_executions.py

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

aws_sdk_lambda/types/resource_arn.py

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

aws_sdk_lambda/types/response_streaming_invocation_type.py

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

aws_sdk_lambda/types/retention_period_in_days.py

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

aws_sdk_lambda/types/retry_details.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RetryDetails``."""
+
+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.duration_seconds
+
+
+class RetryDetails(TypedDict):
+    current_attempt: "aws_sdk_lambda.types.attempt_count.AttemptCount"
+    """<p>The current attempt number for this operation.</p>"""
+    next_attempt_delay_seconds: NotRequired[
+        "aws_sdk_lambda.types.duration_seconds.DurationSeconds"
+    ]
+    """<p>The delay before the next retry attempt, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RetryDetails) -> dict:
+    out: dict = {}
+    out["CurrentAttempt"] = value.get("current_attempt", 0)
+    if "next_attempt_delay_seconds" in value:
+        out["NextAttemptDelaySeconds"] = value["next_attempt_delay_seconds"]
+    return out
+
+
+def deserialize_json(data: dict) -> RetryDetails:
+    out: RetryDetails = {}  # type: ignore[typeddict-item]
+    if "CurrentAttempt" in data:
+        out["current_attempt"] = data["CurrentAttempt"]
+    else:
+        out["current_attempt"] = 0
+    if "NextAttemptDelaySeconds" in data:
+        out["next_attempt_delay_seconds"] = data["NextAttemptDelaySeconds"]
+    return out

aws_sdk_lambda/types/reverse_order.py

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

aws_sdk_lambda/types/role_arn.py

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

aws_sdk_lambda/types/runtime.py

@@ -0,0 +1,117 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Runtime``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+Runtime: TypeAlias = Literal[
+    "nodejs",
+    "nodejs4.3",
+    "nodejs6.10",
+    "nodejs8.10",
+    "nodejs10.x",
+    "nodejs12.x",
+    "nodejs14.x",
+    "nodejs16.x",
+    "java8",
+    "java8.al2",
+    "java11",
+    "python2.7",
+    "python3.6",
+    "python3.7",
+    "python3.8",
+    "python3.9",
+    "dotnetcore1.0",
+    "dotnetcore2.0",
+    "dotnetcore2.1",
+    "dotnetcore3.1",
+    "dotnet6",
+    "dotnet8",
+    "nodejs4.3-edge",
+    "go1.x",
+    "ruby2.5",
+    "ruby2.7",
+    "provided",
+    "provided.al2",
+    "nodejs18.x",
+    "python3.10",
+    "java17",
+    "ruby3.2",
+    "ruby3.3",
+    "ruby3.4",
+    "python3.11",
+    "nodejs20.x",
+    "provided.al2023",
+    "python3.12",
+    "java21",
+    "python3.13",
+    "nodejs22.x",
+    "nodejs24.x",
+    "python3.14",
+    "java25",
+    "dotnet10",
+    "ruby4.0",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "nodejs",
+        "nodejs4.3",
+        "nodejs6.10",
+        "nodejs8.10",
+        "nodejs10.x",
+        "nodejs12.x",
+        "nodejs14.x",
+        "nodejs16.x",
+        "java8",
+        "java8.al2",
+        "java11",
+        "python2.7",
+        "python3.6",
+        "python3.7",
+        "python3.8",
+        "python3.9",
+        "dotnetcore1.0",
+        "dotnetcore2.0",
+        "dotnetcore2.1",
+        "dotnetcore3.1",
+        "dotnet6",
+        "dotnet8",
+        "nodejs4.3-edge",
+        "go1.x",
+        "ruby2.5",
+        "ruby2.7",
+        "provided",
+        "provided.al2",
+        "nodejs18.x",
+        "python3.10",
+        "java17",
+        "ruby3.2",
+        "ruby3.3",
+        "ruby3.4",
+        "python3.11",
+        "nodejs20.x",
+        "provided.al2023",
+        "python3.12",
+        "java21",
+        "python3.13",
+        "nodejs22.x",
+        "nodejs24.x",
+        "python3.14",
+        "java25",
+        "dotnet10",
+        "ruby4.0",
+    )
+)
+
+
+def serialize_json(value: Runtime) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> Runtime:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown Runtime value: {data!r}")
+    return cast(Runtime, data)

aws_sdk_lambda/types/runtime_version_arn.py

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

aws_sdk_lambda/types/runtime_version_config.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RuntimeVersionConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.runtime_version_arn
+    import aws_sdk_lambda.types.runtime_version_error
+
+
+class RuntimeVersionConfig(TypedDict):
+    runtime_version_arn: NotRequired[
+        "aws_sdk_lambda.types.runtime_version_arn.RuntimeVersionArn"
+    ]
+    """<p>The ARN of the runtime version you want the function to use.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.runtime_version_error.RuntimeVersionError"]
+    """<p>Error response when Lambda is unable to retrieve the runtime version for a function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RuntimeVersionConfig) -> dict:
+    out: dict = {}
+    if "runtime_version_arn" in value:
+        out["RuntimeVersionArn"] = value["runtime_version_arn"]
+    if "error" in value:
+        import aws_sdk_lambda.types.runtime_version_error
+
+        out["Error"] = aws_sdk_lambda.types.runtime_version_error.serialize_json(
+            value["error"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> RuntimeVersionConfig:
+    out: RuntimeVersionConfig = {}  # type: ignore[typeddict-item]
+    if "RuntimeVersionArn" in data:
+        out["runtime_version_arn"] = data["RuntimeVersionArn"]
+    if "Error" in data:
+        import aws_sdk_lambda.types.runtime_version_error
+
+        out["error"] = aws_sdk_lambda.types.runtime_version_error.deserialize_json(
+            data["Error"]
+        )
+    return out

aws_sdk_lambda/types/runtime_version_error.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#RuntimeVersionError``."""
+
+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 RuntimeVersionError(TypedDict):
+    error_code: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The error code.</p>"""
+    message: NotRequired["aws_sdk_lambda.types.sensitive_string.SensitiveString"]
+    """<p>The error message.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RuntimeVersionError) -> 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) -> RuntimeVersionError:
+    out: RuntimeVersionError = {}  # 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/s3_bucket.py

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

aws_sdk_lambda/types/s3_key.py

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

aws_sdk_lambda/types/s3_object_version.py

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

aws_sdk_lambda/types/scaling_config.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ScalingConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.maximum_concurrency
+
+
+class ScalingConfig(TypedDict):
+    maximum_concurrency: NotRequired[
+        "aws_sdk_lambda.types.maximum_concurrency.MaximumConcurrency"
+    ]
+    """<p>Limits the number of concurrent instances that the Amazon SQS event source can invoke.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ScalingConfig) -> dict:
+    out: dict = {}
+    if "maximum_concurrency" in value:
+        out["MaximumConcurrency"] = value["maximum_concurrency"]
+    return out
+
+
+def deserialize_json(data: dict) -> ScalingConfig:
+    out: ScalingConfig = {}  # type: ignore[typeddict-item]
+    if "MaximumConcurrency" in data:
+        out["maximum_concurrency"] = data["MaximumConcurrency"]
+    return out

aws_sdk_lambda/types/schema_registry_event_record_format.py

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

aws_sdk_lambda/types/schema_registry_uri.py

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

aws_sdk_lambda/types/security_group_id.py

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

aws_sdk_lambda/types/security_group_ids.py

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

aws_sdk_lambda/types/self_managed_event_source.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SelfManagedEventSource``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.endpoints
+
+
+class SelfManagedEventSource(TypedDict):
+    endpoints: NotRequired["aws_sdk_lambda.types.endpoints.Endpoints"]
+    """<p>The list of bootstrap servers for your Kafka brokers in the following format: <code>\"KAFKA_BOOTSTRAP_SERVERS\": [\"abc.xyz.com:xxxx\",\"abc2.xyz.com:xxxx\"]</code>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SelfManagedEventSource) -> dict:
+    out: dict = {}
+    if "endpoints" in value:
+        import aws_sdk_lambda.types.endpoints
+
+        out["Endpoints"] = aws_sdk_lambda.types.endpoints.serialize_json(
+            value["endpoints"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SelfManagedEventSource:
+    out: SelfManagedEventSource = {}  # type: ignore[typeddict-item]
+    if "Endpoints" in data:
+        import aws_sdk_lambda.types.endpoints
+
+        out["endpoints"] = aws_sdk_lambda.types.endpoints.deserialize_json(
+            data["Endpoints"]
+        )
+    return out

aws_sdk_lambda/types/self_managed_kafka_event_source_config.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SelfManagedKafkaEventSourceConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.kafka_schema_registry_config
+    import aws_sdk_lambda.types.uri
+
+
+class SelfManagedKafkaEventSourceConfig(TypedDict):
+    consumer_group_id: NotRequired["aws_sdk_lambda.types.uri.URI"]
+    """<p> The identifier for the Kafka consumer group to join. The consumer group ID must be unique among all your Kafka event sources. After creating a Kafka event source mapping with the consumer group ID specified, you cannot update this value. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/with-kafka-process.html#services-smaa-topic-add\">Customizable consumer group ID</a>.</p>"""
+    schema_registry_config: NotRequired[
+        "aws_sdk_lambda.types.kafka_schema_registry_config.KafkaSchemaRegistryConfig"
+    ]
+    """<p>Specific configuration settings for a Kafka schema registry.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SelfManagedKafkaEventSourceConfig) -> dict:
+    out: dict = {}
+    if "consumer_group_id" in value:
+        out["ConsumerGroupId"] = value["consumer_group_id"]
+    if "schema_registry_config" in value:
+        import aws_sdk_lambda.types.kafka_schema_registry_config
+
+        out["SchemaRegistryConfig"] = (
+            aws_sdk_lambda.types.kafka_schema_registry_config.serialize_json(
+                value["schema_registry_config"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> SelfManagedKafkaEventSourceConfig:
+    out: SelfManagedKafkaEventSourceConfig = {}  # type: ignore[typeddict-item]
+    if "ConsumerGroupId" in data:
+        out["consumer_group_id"] = data["ConsumerGroupId"]
+    if "SchemaRegistryConfig" in data:
+        import aws_sdk_lambda.types.kafka_schema_registry_config
+
+        out["schema_registry_config"] = (
+            aws_sdk_lambda.types.kafka_schema_registry_config.deserialize_json(
+                data["SchemaRegistryConfig"]
+            )
+        )
+    return out

aws_sdk_lambda/types/send_durable_execution_callback_failure_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackFailureRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.callback_id
+    import aws_sdk_lambda.types.error_object
+
+
+class SendDurableExecutionCallbackFailureRequest(TypedDict):
+    callback_id: "aws_sdk_lambda.types.callback_id.CallbackId"
+    """<p>The unique identifier for the callback operation.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.error_object.ErrorObject"]
+    """<p>Error details describing why the callback operation failed.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackFailureRequest) -> dict:
+    out: dict = {}
+    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) -> SendDurableExecutionCallbackFailureRequest:
+    out: SendDurableExecutionCallbackFailureRequest = {}  # type: ignore[typeddict-item]
+    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/send_durable_execution_callback_failure_response.py

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

aws_sdk_lambda/types/send_durable_execution_callback_heartbeat_request.py

@@ -0,0 +1,22 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SendDurableExecutionCallbackHeartbeatRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.callback_id
+
+
+class SendDurableExecutionCallbackHeartbeatRequest(TypedDict):
+    callback_id: "aws_sdk_lambda.types.callback_id.CallbackId"
+    """<p>The unique identifier for the callback operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SendDurableExecutionCallbackHeartbeatRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> SendDurableExecutionCallbackHeartbeatRequest:
+    out: SendDurableExecutionCallbackHeartbeatRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/send_durable_execution_callback_heartbeat_response.py

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