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

aws_sdk_lambda/types/event_source_mapping_metrics_config.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#EventSourceMappingMetricsConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_source_mapping_metric_list
+
+
+class EventSourceMappingMetricsConfig(TypedDict):
+    metrics: NotRequired[
+        "aws_sdk_lambda.types.event_source_mapping_metric_list.EventSourceMappingMetricList"
+    ]
+    """<p> The metrics you want your event source mapping to produce, including <code>EventCount</code>, <code>ErrorCount</code>, <code>KafkaMetrics</code>. </p> <ul> <li> <p> <code>EventCount</code> to receive metrics related to the number of events processed by your event source mapping.</p> </li> <li> <p> <code>ErrorCount</code> (Amazon MSK and self-managed Apache Kafka) to receive metrics related to the number of errors in your event source mapping processing.</p> </li> <li> <p> <code>KafkaMetrics</code> (Amazon MSK and self-managed Apache Kafka) to receive metrics related to the Kafka consumers from your event source mapping.</p> </li> </ul> <p> For more information about these metrics, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/monitoring-metrics-types.html#event-source-mapping-metrics\"> Event source mapping metrics</a>. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: EventSourceMappingMetricsConfig) -> dict:
+    out: dict = {}
+    if "metrics" in value:
+        import aws_sdk_lambda.types.event_source_mapping_metric_list
+
+        out["Metrics"] = (
+            aws_sdk_lambda.types.event_source_mapping_metric_list.serialize_json(
+                value["metrics"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> EventSourceMappingMetricsConfig:
+    out: EventSourceMappingMetricsConfig = {}  # type: ignore[typeddict-item]
+    if "Metrics" in data:
+        import aws_sdk_lambda.types.event_source_mapping_metric_list
+
+        out["metrics"] = (
+            aws_sdk_lambda.types.event_source_mapping_metric_list.deserialize_json(
+                data["Metrics"]
+            )
+        )
+    return out

aws_sdk_lambda/types/event_source_mapping_system_log_level.py

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

aws_sdk_lambda/types/event_source_mappings_list.py

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

aws_sdk_lambda/types/event_source_position.py

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

aws_sdk_lambda/types/event_source_token.py

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

aws_sdk_lambda/types/event_type.py

@@ -0,0 +1,73 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#EventType``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+EventType: TypeAlias = Literal[
+    "ExecutionStarted",
+    "ExecutionSucceeded",
+    "ExecutionFailed",
+    "ExecutionTimedOut",
+    "ExecutionStopped",
+    "ContextStarted",
+    "ContextSucceeded",
+    "ContextFailed",
+    "WaitStarted",
+    "WaitSucceeded",
+    "WaitCancelled",
+    "StepStarted",
+    "StepSucceeded",
+    "StepFailed",
+    "ChainedInvokeStarted",
+    "ChainedInvokeSucceeded",
+    "ChainedInvokeFailed",
+    "ChainedInvokeTimedOut",
+    "ChainedInvokeStopped",
+    "CallbackStarted",
+    "CallbackSucceeded",
+    "CallbackFailed",
+    "CallbackTimedOut",
+    "InvocationCompleted",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "ExecutionStarted",
+        "ExecutionSucceeded",
+        "ExecutionFailed",
+        "ExecutionTimedOut",
+        "ExecutionStopped",
+        "ContextStarted",
+        "ContextSucceeded",
+        "ContextFailed",
+        "WaitStarted",
+        "WaitSucceeded",
+        "WaitCancelled",
+        "StepStarted",
+        "StepSucceeded",
+        "StepFailed",
+        "ChainedInvokeStarted",
+        "ChainedInvokeSucceeded",
+        "ChainedInvokeFailed",
+        "ChainedInvokeTimedOut",
+        "ChainedInvokeStopped",
+        "CallbackStarted",
+        "CallbackSucceeded",
+        "CallbackFailed",
+        "CallbackTimedOut",
+        "InvocationCompleted",
+    )
+)
+
+
+def serialize_json(value: EventType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> EventType:
+    if data not in _VALUES:
+        raise DeserializationError(f"unknown EventType value: {data!r}")
+    return cast(EventType, data)

aws_sdk_lambda/types/events.py

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

aws_sdk_lambda/types/execution.py

@@ -0,0 +1,103 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Execution``."""
+
+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.durable_execution_arn
+    import aws_sdk_lambda.types.durable_execution_name
+    import aws_sdk_lambda.types.execution_status
+    import aws_sdk_lambda.types.execution_timestamp
+    import aws_sdk_lambda.types.name_spaced_function_arn
+
+
+class Execution(TypedDict):
+    durable_execution_arn: (
+        "aws_sdk_lambda.types.durable_execution_arn.DurableExecutionArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the durable execution, if this execution is a durable execution.</p>"""
+    durable_execution_name: (
+        "aws_sdk_lambda.types.durable_execution_name.DurableExecutionName"
+    )
+    """<p>The unique name of the durable execution, if one was provided when the execution was started.</p>"""
+    function_arn: "aws_sdk_lambda.types.name_spaced_function_arn.NameSpacedFunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the Lambda function.</p>"""
+    status: "aws_sdk_lambda.types.execution_status.ExecutionStatus"
+    """<p>The current status of the durable execution.</p>"""
+    start_timestamp: "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    """<p>The date and time when the durable execution started, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    end_timestamp: NotRequired[
+        "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    """<p>The date and time when the durable execution ended, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Execution) -> dict:
+    out: dict = {}
+    out["DurableExecutionArn"] = value["durable_execution_arn"]
+    out["DurableExecutionName"] = value["durable_execution_name"]
+    out["FunctionArn"] = value["function_arn"]
+    import aws_sdk_lambda.types.execution_status
+
+    out["Status"] = aws_sdk_lambda.types.execution_status.serialize_json(
+        value["status"]
+    )
+    import aws_sdk_lambda.types.execution_timestamp
+
+    out["StartTimestamp"] = aws_sdk_lambda.types.execution_timestamp.serialize_json(
+        value["start_timestamp"]
+    )
+    if "end_timestamp" in value:
+        import aws_sdk_lambda.types.execution_timestamp
+
+        out["EndTimestamp"] = aws_sdk_lambda.types.execution_timestamp.serialize_json(
+            value["end_timestamp"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> Execution:
+    out: Execution = {}  # type: ignore[typeddict-item]
+    if "DurableExecutionArn" in data:
+        out["durable_execution_arn"] = data["DurableExecutionArn"]
+    else:
+        raise DeserializationError("Execution.durable_execution_arn required")
+    if "DurableExecutionName" in data:
+        out["durable_execution_name"] = data["DurableExecutionName"]
+    else:
+        raise DeserializationError("Execution.durable_execution_name required")
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError("Execution.function_arn required")
+    if "Status" in data:
+        import aws_sdk_lambda.types.execution_status
+
+        out["status"] = aws_sdk_lambda.types.execution_status.deserialize_json(
+            data["Status"]
+        )
+    else:
+        raise DeserializationError("Execution.status required")
+    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("Execution.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"]
+            )
+        )
+    return out

aws_sdk_lambda/types/execution_details.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.input_payload
+
+
+class ExecutionDetails(TypedDict):
+    input_payload: NotRequired["aws_sdk_lambda.types.input_payload.InputPayload"]
+    """<p>The original input payload provided for the durable execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionDetails) -> dict:
+    out: dict = {}
+    if "input_payload" in value:
+        out["InputPayload"] = value["input_payload"]
+    return out
+
+
+def deserialize_json(data: dict) -> ExecutionDetails:
+    out: ExecutionDetails = {}  # type: ignore[typeddict-item]
+    if "InputPayload" in data:
+        out["input_payload"] = data["InputPayload"]
+    return out

aws_sdk_lambda/types/execution_environment_memory_gi_b_per_v_cpu.py

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

aws_sdk_lambda/types/execution_failed_details.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionFailedDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_error
+
+
+class ExecutionFailedDetails(TypedDict):
+    error: "aws_sdk_lambda.types.event_error.EventError"
+    """<p>Details about the execution failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionFailedDetails) -> 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) -> ExecutionFailedDetails:
+    out: ExecutionFailedDetails = {}  # 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("ExecutionFailedDetails.error required")
+    return out

aws_sdk_lambda/types/execution_started_details.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionStartedDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.duration_seconds
+    import aws_sdk_lambda.types.event_input
+
+
+class ExecutionStartedDetails(TypedDict):
+    input: "aws_sdk_lambda.types.event_input.EventInput"
+    """<p>The input payload provided for the durable execution.</p>"""
+    execution_timeout: "aws_sdk_lambda.types.duration_seconds.DurationSeconds"
+    """<p>The maximum amount of time that the durable execution is allowed to run, in seconds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionStartedDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.event_input
+
+    out["Input"] = aws_sdk_lambda.types.event_input.serialize_json(value["input"])
+    out["ExecutionTimeout"] = value["execution_timeout"]
+    return out
+
+
+def deserialize_json(data: dict) -> ExecutionStartedDetails:
+    out: ExecutionStartedDetails = {}  # type: ignore[typeddict-item]
+    if "Input" in data:
+        import aws_sdk_lambda.types.event_input
+
+        out["input"] = aws_sdk_lambda.types.event_input.deserialize_json(data["Input"])
+    else:
+        raise DeserializationError("ExecutionStartedDetails.input required")
+    if "ExecutionTimeout" in data:
+        out["execution_timeout"] = data["ExecutionTimeout"]
+    else:
+        raise DeserializationError("ExecutionStartedDetails.execution_timeout required")
+    return out

aws_sdk_lambda/types/execution_status.py

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

aws_sdk_lambda/types/execution_status_list.py

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

aws_sdk_lambda/types/execution_stopped_details.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionStoppedDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_error
+
+
+class ExecutionStoppedDetails(TypedDict):
+    error: "aws_sdk_lambda.types.event_error.EventError"
+    """<p>Details about why the execution stopped.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionStoppedDetails) -> 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) -> ExecutionStoppedDetails:
+    out: ExecutionStoppedDetails = {}  # 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("ExecutionStoppedDetails.error required")
+    return out

aws_sdk_lambda/types/execution_succeeded_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionSucceededDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_result
+
+
+class ExecutionSucceededDetails(TypedDict):
+    result: "aws_sdk_lambda.types.event_result.EventResult"
+    """<p>The response payload from the successful operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionSucceededDetails) -> 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) -> ExecutionSucceededDetails:
+    out: ExecutionSucceededDetails = {}  # 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("ExecutionSucceededDetails.result required")
+    return out

aws_sdk_lambda/types/execution_timed_out_details.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionTimedOutDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_error
+
+
+class ExecutionTimedOutDetails(TypedDict):
+    error: NotRequired["aws_sdk_lambda.types.event_error.EventError"]
+    """<p>Details about the execution timeout.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionTimedOutDetails) -> dict:
+    out: dict = {}
+    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) -> ExecutionTimedOutDetails:
+    out: ExecutionTimedOutDetails = {}  # 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"])
+    return out

aws_sdk_lambda/types/execution_timeout.py

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

aws_sdk_lambda/types/execution_timestamp.py

@@ -0,0 +1,15 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ExecutionTimestamp``."""
+
+import datetime
+from typing import TypeAlias
+
+ExecutionTimestamp: TypeAlias = datetime.datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ExecutionTimestamp) -> float:
+    return value.timestamp()
+
+
+def deserialize_json(data: float) -> ExecutionTimestamp:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

aws_sdk_lambda/types/file_system_arn.py

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