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

aws_sdk_lambda/types/get_durable_execution_history_request.py

@@ -0,0 +1,40 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionHistoryRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.durable_execution_arn
+    import aws_sdk_lambda.types.include_execution_data
+    import aws_sdk_lambda.types.item_count
+    import aws_sdk_lambda.types.reverse_order
+    import aws_sdk_lambda.types.string
+
+
+class GetDurableExecutionHistoryRequest(TypedDict):
+    durable_execution_arn: (
+        "aws_sdk_lambda.types.durable_execution_arn.DurableExecutionArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    include_execution_data: NotRequired[
+        "aws_sdk_lambda.types.include_execution_data.IncludeExecutionData"
+    ]
+    """<p>Specifies whether to include execution data such as step results and callback payloads in the history events. Set to <code>true</code> to include data, or <code>false</code> to exclude it for a more compact response. The default is <code>true</code>.</p>"""
+    max_items: "aws_sdk_lambda.types.item_count.ItemCount"
+    """<p>The maximum number of history events to return per call. You can use <code>Marker</code> to retrieve additional pages of results. The default is 100 and the maximum allowed is 1000. A value of 0 uses the default.</p>"""
+    marker: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>If <code>NextMarker</code> was returned from a previous request, use this value to retrieve the next page of results. Each pagination token expires after 24 hours.</p>"""
+    reverse_order: NotRequired["aws_sdk_lambda.types.reverse_order.ReverseOrder"]
+    """<p>When set to <code>true</code>, returns the history events in reverse chronological order (newest first). By default, events are returned in chronological order (oldest first).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDurableExecutionHistoryRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetDurableExecutionHistoryRequest:
+    out: GetDurableExecutionHistoryRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_durable_execution_history_response.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionHistoryResponse``."""
+
+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.events
+    import aws_sdk_lambda.types.string
+
+
+class GetDurableExecutionHistoryResponse(TypedDict):
+    events: "aws_sdk_lambda.types.events.Events"
+    """<p>An array of execution history events, ordered chronologically unless <code>ReverseOrder</code> is set to <code>true</code>. Each event represents a significant occurrence during the execution, such as step completion or callback resolution.</p>"""
+    next_marker: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>If present, indicates that more history events are available. Use this value as the <code>Marker</code> parameter in a subsequent request to retrieve the next page of results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDurableExecutionHistoryResponse) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.events
+
+    out["Events"] = aws_sdk_lambda.types.events.serialize_json(value["events"])
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetDurableExecutionHistoryResponse:
+    out: GetDurableExecutionHistoryResponse = {}  # type: ignore[typeddict-item]
+    if "Events" in data:
+        import aws_sdk_lambda.types.events
+
+        out["events"] = aws_sdk_lambda.types.events.deserialize_json(data["Events"])
+    else:
+        raise DeserializationError("GetDurableExecutionHistoryResponse.events required")
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

aws_sdk_lambda/types/get_durable_execution_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.durable_execution_arn
+
+
+class GetDurableExecutionRequest(TypedDict):
+    durable_execution_arn: (
+        "aws_sdk_lambda.types.durable_execution_arn.DurableExecutionArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDurableExecutionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetDurableExecutionRequest:
+    out: GetDurableExecutionRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_durable_execution_response.py

@@ -0,0 +1,158 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionResponse``."""
+
+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.error_object
+    import aws_sdk_lambda.types.execution_status
+    import aws_sdk_lambda.types.execution_timestamp
+    import aws_sdk_lambda.types.input_payload
+    import aws_sdk_lambda.types.name_spaced_function_arn
+    import aws_sdk_lambda.types.output_payload
+    import aws_sdk_lambda.types.trace_header
+    import aws_sdk_lambda.types.version_with_latest_published
+
+
+class GetDurableExecutionResponse(TypedDict):
+    durable_execution_arn: (
+        "aws_sdk_lambda.types.durable_execution_arn.DurableExecutionArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    durable_execution_name: (
+        "aws_sdk_lambda.types.durable_execution_name.DurableExecutionName"
+    )
+    """<p>The name of the durable execution. This is either the name you provided when invoking the function, or a system-generated unique identifier if no name was provided.</p>"""
+    function_arn: "aws_sdk_lambda.types.name_spaced_function_arn.NameSpacedFunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the Lambda function that was invoked to start this durable execution.</p>"""
+    input_payload: NotRequired["aws_sdk_lambda.types.input_payload.InputPayload"]
+    """<p>The JSON input payload that was provided when the durable execution was started. For asynchronous invocations, this is limited to 256 KB. For synchronous invocations, this can be up to 6 MB.</p>"""
+    result: NotRequired["aws_sdk_lambda.types.output_payload.OutputPayload"]
+    """<p>The JSON result returned by the durable execution if it completed successfully. This field is only present when the execution status is <code>SUCCEEDED</code>. The result is limited to 256 KB.</p>"""
+    error: NotRequired["aws_sdk_lambda.types.error_object.ErrorObject"]
+    """<p>Error information if the durable execution failed. This field is only present when the execution status is <code>FAILED</code>, <code>TIMED_OUT</code>, or <code>STOPPED</code>. The combined size of all error fields is limited to 256 KB.</p>"""
+    start_timestamp: "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    """<p>The date and time when the durable execution started, in Unix timestamp format.</p>"""
+    status: "aws_sdk_lambda.types.execution_status.ExecutionStatus"
+    """<p>The current status of the durable execution. Valid values are <code>RUNNING</code>, <code>SUCCEEDED</code>, <code>FAILED</code>, <code>TIMED_OUT</code>, and <code>STOPPED</code>.</p>"""
+    end_timestamp: NotRequired[
+        "aws_sdk_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    """<p>The date and time when the durable execution ended, in Unix timestamp format. This field is only present if the execution has completed (status is <code>SUCCEEDED</code>, <code>FAILED</code>, <code>TIMED_OUT</code>, or <code>STOPPED</code>).</p>"""
+    version: NotRequired[
+        "aws_sdk_lambda.types.version_with_latest_published.VersionWithLatestPublished"
+    ]
+    """<p>The version of the Lambda function that was invoked for this durable execution. This ensures that all replays during the execution use the same function version.</p>"""
+    trace_header: NotRequired["aws_sdk_lambda.types.trace_header.TraceHeader"]
+    """<p>The trace headers associated with the durable execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDurableExecutionResponse) -> dict:
+    out: dict = {}
+    out["DurableExecutionArn"] = value["durable_execution_arn"]
+    out["DurableExecutionName"] = value["durable_execution_name"]
+    out["FunctionArn"] = value["function_arn"]
+    if "input_payload" in value:
+        out["InputPayload"] = value["input_payload"]
+    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"])
+    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_status
+
+    out["Status"] = aws_sdk_lambda.types.execution_status.serialize_json(
+        value["status"]
+    )
+    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"]
+        )
+    if "version" in value:
+        out["Version"] = value["version"]
+    if "trace_header" in value:
+        import aws_sdk_lambda.types.trace_header
+
+        out["TraceHeader"] = aws_sdk_lambda.types.trace_header.serialize_json(
+            value["trace_header"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetDurableExecutionResponse:
+    out: GetDurableExecutionResponse = {}  # type: ignore[typeddict-item]
+    if "DurableExecutionArn" in data:
+        out["durable_execution_arn"] = data["DurableExecutionArn"]
+    else:
+        raise DeserializationError(
+            "GetDurableExecutionResponse.durable_execution_arn required"
+        )
+    if "DurableExecutionName" in data:
+        out["durable_execution_name"] = data["DurableExecutionName"]
+    else:
+        raise DeserializationError(
+            "GetDurableExecutionResponse.durable_execution_name required"
+        )
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError("GetDurableExecutionResponse.function_arn required")
+    if "InputPayload" in data:
+        out["input_payload"] = data["InputPayload"]
+    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"])
+    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(
+            "GetDurableExecutionResponse.start_timestamp 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("GetDurableExecutionResponse.status 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"]
+            )
+        )
+    if "Version" in data:
+        out["version"] = data["Version"]
+    if "TraceHeader" in data:
+        import aws_sdk_lambda.types.trace_header
+
+        out["trace_header"] = aws_sdk_lambda.types.trace_header.deserialize_json(
+            data["TraceHeader"]
+        )
+    return out

aws_sdk_lambda/types/get_durable_execution_state_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionStateRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.checkpoint_token
+    import aws_sdk_lambda.types.durable_execution_arn
+    import aws_sdk_lambda.types.item_count
+    import aws_sdk_lambda.types.string
+
+
+class GetDurableExecutionStateRequest(TypedDict):
+    durable_execution_arn: (
+        "aws_sdk_lambda.types.durable_execution_arn.DurableExecutionArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    checkpoint_token: "aws_sdk_lambda.types.checkpoint_token.CheckpointToken"
+    """<p>A checkpoint token that identifies the current state of the execution. This token is provided by the Lambda runtime and ensures that state retrieval is consistent with the current execution context.</p>"""
+    marker: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>If <code>NextMarker</code> was returned from a previous request, use this value to retrieve the next page of operations. Each pagination token expires after 24 hours.</p>"""
+    max_items: "aws_sdk_lambda.types.item_count.ItemCount"
+    """<p>The maximum number of operations to return per call. You can use <code>Marker</code> to retrieve additional pages of results. The default is 100 and the maximum allowed is 1000. A value of 0 uses the default.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDurableExecutionStateRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetDurableExecutionStateRequest:
+    out: GetDurableExecutionStateRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_durable_execution_state_response.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionStateResponse``."""
+
+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.operations
+    import aws_sdk_lambda.types.string
+
+
+class GetDurableExecutionStateResponse(TypedDict):
+    operations: "aws_sdk_lambda.types.operations.Operations"
+    """<p>An array of operations that represent the current state of the durable execution. Operations are ordered by their start sequence number in ascending order and include information needed for replay processing.</p>"""
+    next_marker: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>If present, indicates that more operations are available. Use this value as the <code>Marker</code> parameter in a subsequent request to retrieve the next page of results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetDurableExecutionStateResponse) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.operations
+
+    out["Operations"] = aws_sdk_lambda.types.operations.serialize_json(
+        value["operations"]
+    )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetDurableExecutionStateResponse:
+    out: GetDurableExecutionStateResponse = {}  # type: ignore[typeddict-item]
+    if "Operations" in data:
+        import aws_sdk_lambda.types.operations
+
+        out["operations"] = aws_sdk_lambda.types.operations.deserialize_json(
+            data["Operations"]
+        )
+    else:
+        raise DeserializationError(
+            "GetDurableExecutionStateResponse.operations required"
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

aws_sdk_lambda/types/get_event_source_mapping_request.py

@@ -0,0 +1,22 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetEventSourceMappingRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class GetEventSourceMappingRequest(TypedDict):
+    uuid: "aws_sdk_lambda.types.string.String"
+    """<p>The identifier of the event source mapping.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetEventSourceMappingRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetEventSourceMappingRequest:
+    out: GetEventSourceMappingRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_code_signing_config_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionCodeSigningConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.namespaced_function_name
+
+
+class GetFunctionCodeSigningConfigRequest(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>MyFunction</code>.</p> </li> <li> <p> <b>Function ARN</b> - <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction</code>.</p> </li> <li> <p> <b>Partial ARN</b> - <code>123456789012:function:MyFunction</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionCodeSigningConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionCodeSigningConfigRequest:
+    out: GetFunctionCodeSigningConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_code_signing_config_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionCodeSigningConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.code_signing_config_arn
+    import aws_sdk_lambda.types.function_name
+
+
+class GetFunctionCodeSigningConfigResponse(TypedDict):
+    code_signing_config_arn: (
+        "aws_sdk_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration.</p>"""
+    function_name: "aws_sdk_lambda.types.function_name.FunctionName"
+    """<p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> - <code>MyFunction</code>.</p> </li> <li> <p> <b>Function ARN</b> - <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction</code>.</p> </li> <li> <p> <b>Partial ARN</b> - <code>123456789012:function:MyFunction</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionCodeSigningConfigResponse) -> dict:
+    out: dict = {}
+    out["CodeSigningConfigArn"] = value["code_signing_config_arn"]
+    out["FunctionName"] = value["function_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionCodeSigningConfigResponse:
+    out: GetFunctionCodeSigningConfigResponse = {}  # type: ignore[typeddict-item]
+    if "CodeSigningConfigArn" in data:
+        out["code_signing_config_arn"] = data["CodeSigningConfigArn"]
+    else:
+        raise DeserializationError(
+            "GetFunctionCodeSigningConfigResponse.code_signing_config_arn required"
+        )
+    if "FunctionName" in data:
+        out["function_name"] = data["FunctionName"]
+    else:
+        raise DeserializationError(
+            "GetFunctionCodeSigningConfigResponse.function_name required"
+        )
+    return out

aws_sdk_lambda/types/get_function_concurrency_request.py

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

aws_sdk_lambda/types/get_function_concurrency_response.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionConcurrencyResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.reserved_concurrent_executions
+
+
+class GetFunctionConcurrencyResponse(TypedDict):
+    reserved_concurrent_executions: NotRequired[
+        "aws_sdk_lambda.types.reserved_concurrent_executions.ReservedConcurrentExecutions"
+    ]
+    """<p>The number of simultaneous executions that are reserved for the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionConcurrencyResponse) -> dict:
+    out: dict = {}
+    if "reserved_concurrent_executions" in value:
+        out["ReservedConcurrentExecutions"] = value["reserved_concurrent_executions"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionConcurrencyResponse:
+    out: GetFunctionConcurrencyResponse = {}  # type: ignore[typeddict-item]
+    if "ReservedConcurrentExecutions" in data:
+        out["reserved_concurrent_executions"] = data["ReservedConcurrentExecutions"]
+    return out

aws_sdk_lambda/types/get_function_configuration_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionConfigurationRequest``."""
+
+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 GetFunctionConfigurationRequest(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>"""
+    qualifier: NotRequired[
+        "aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version or alias to get details about a published version of the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionConfigurationRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionConfigurationRequest:
+    out: GetFunctionConfigurationRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_event_invoke_config_request.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionEventInvokeConfigRequest``."""
+
+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 GetFunctionEventInvokeConfigRequest(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>"""
+    qualifier: NotRequired[
+        "aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>A version number or alias name.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionEventInvokeConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionEventInvokeConfigRequest:
+    out: GetFunctionEventInvokeConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_recursion_config_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionRecursionConfigRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.unqualified_function_name
+
+
+class GetFunctionRecursionConfigRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.unqualified_function_name.UnqualifiedFunctionName"
+    )
+    """<p>The name of the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionRecursionConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionRecursionConfigRequest:
+    out: GetFunctionRecursionConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

aws_sdk_lambda/types/get_function_recursion_config_response.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetFunctionRecursionConfigResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.recursive_loop
+
+
+class GetFunctionRecursionConfigResponse(TypedDict):
+    recursive_loop: NotRequired["aws_sdk_lambda.types.recursive_loop.RecursiveLoop"]
+    """<p>If your function's recursive loop detection configuration is <code>Allow</code>, Lambda doesn't take any action when it detects your function being invoked as part of a recursive loop.</p> <p>If your function's recursive loop detection configuration is <code>Terminate</code>, Lambda stops your function being invoked and notifies you when it detects your function being invoked as part of a recursive loop.</p> <p>By default, Lambda sets your function's configuration to <code>Terminate</code>. You can update this configuration using the <a>PutFunctionRecursionConfig</a> action.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetFunctionRecursionConfigResponse) -> dict:
+    out: dict = {}
+    if "recursive_loop" in value:
+        import aws_sdk_lambda.types.recursive_loop
+
+        out["RecursiveLoop"] = aws_sdk_lambda.types.recursive_loop.serialize_json(
+            value["recursive_loop"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetFunctionRecursionConfigResponse:
+    out: GetFunctionRecursionConfigResponse = {}  # type: ignore[typeddict-item]
+    if "RecursiveLoop" in data:
+        import aws_sdk_lambda.types.recursive_loop
+
+        out["recursive_loop"] = aws_sdk_lambda.types.recursive_loop.deserialize_json(
+            data["RecursiveLoop"]
+        )
+    return out