capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/get_provisioned_concurrency_config_response.py

@@ -0,0 +1,94 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetProvisionedConcurrencyConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.non_negative_integer
+    import capo_lambda.types.positive_integer
+    import capo_lambda.types.provisioned_concurrency_status_enum
+    import capo_lambda.types.string
+    import capo_lambda.types.timestamp
+
+
+class GetProvisionedConcurrencyConfigResponse(TypedDict, closed=True):
+    requested_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.positive_integer.PositiveInteger"
+    ]
+    """<p>The amount of provisioned concurrency requested.</p>"""
+    available_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency available.</p>"""
+    allocated_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency allocated. When a weighted alias is used during linear and canary deployments, this value fluctuates depending on the amount of concurrency that is provisioned for the function versions.</p>"""
+    status: NotRequired[
+        "capo_lambda.types.provisioned_concurrency_status_enum.ProvisionedConcurrencyStatusEnum"
+    ]
+    """<p>The status of the allocation process.</p>"""
+    status_reason: NotRequired["capo_lambda.types.string.String"]
+    """<p>For failed allocations, the reason that provisioned concurrency could not be allocated.</p>"""
+    last_modified: NotRequired["capo_lambda.types.timestamp.Timestamp"]
+    r"""<p>The date and time that a user last updated the configuration, in <a href=\"https://www.iso.org/iso-8601-date-and-time-format.html\">ISO 8601 format</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetProvisionedConcurrencyConfigResponse) -> dict:
+    out: dict = {}
+    if "requested_provisioned_concurrent_executions" in value:
+        out["RequestedProvisionedConcurrentExecutions"] = value[
+            "requested_provisioned_concurrent_executions"
+        ]
+    if "available_provisioned_concurrent_executions" in value:
+        out["AvailableProvisionedConcurrentExecutions"] = value[
+            "available_provisioned_concurrent_executions"
+        ]
+    if "allocated_provisioned_concurrent_executions" in value:
+        out["AllocatedProvisionedConcurrentExecutions"] = value[
+            "allocated_provisioned_concurrent_executions"
+        ]
+    if "status" in value:
+        import capo_lambda.types.provisioned_concurrency_status_enum
+
+        out["Status"] = (
+            capo_lambda.types.provisioned_concurrency_status_enum.serialize_json(
+                value["status"]
+            )
+        )
+    if "status_reason" in value:
+        out["StatusReason"] = value["status_reason"]
+    if "last_modified" in value:
+        out["LastModified"] = value["last_modified"]
+    return out
+
+
+def deserialize_json(data: dict) -> GetProvisionedConcurrencyConfigResponse:
+    out: GetProvisionedConcurrencyConfigResponse = {}  # type: ignore[typeddict-item]
+    if "RequestedProvisionedConcurrentExecutions" in data:
+        out["requested_provisioned_concurrent_executions"] = data[
+            "RequestedProvisionedConcurrentExecutions"
+        ]
+    if "AvailableProvisionedConcurrentExecutions" in data:
+        out["available_provisioned_concurrent_executions"] = data[
+            "AvailableProvisionedConcurrentExecutions"
+        ]
+    if "AllocatedProvisionedConcurrentExecutions" in data:
+        out["allocated_provisioned_concurrent_executions"] = data[
+            "AllocatedProvisionedConcurrentExecutions"
+        ]
+    if "Status" in data:
+        import capo_lambda.types.provisioned_concurrency_status_enum
+
+        out["status"] = (
+            capo_lambda.types.provisioned_concurrency_status_enum.deserialize_json(
+                data["Status"]
+            )
+        )
+    if "StatusReason" in data:
+        out["status_reason"] = data["StatusReason"]
+    if "LastModified" in data:
+        out["last_modified"] = data["LastModified"]
+    return out

capo_lambda/types/get_runtime_management_config_request.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetRuntimeManagementConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+
+
+class GetRuntimeManagementConfigRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    r"""<p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version of the function. This can be <code>$LATEST</code> or a published version number. If no value is specified, the configuration for the <code>$LATEST</code> version is returned.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetRuntimeManagementConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetRuntimeManagementConfigRequest:
+    out: GetRuntimeManagementConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/get_runtime_management_config_response.py

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

capo_lambda/types/handler.py

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

capo_lambda/types/header.py

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

capo_lambda/types/headers_list.py

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

capo_lambda/types/http_status.py

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

capo_lambda/types/image_config.py

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

capo_lambda/types/image_config_error.py

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

capo_lambda/types/image_config_response.py

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

capo_lambda/types/include_execution_data.py

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

capo_lambda/types/input_payload.py

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

capo_lambda/types/instance_requirements.py

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

capo_lambda/types/instance_type.py

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

capo_lambda/types/instance_type_set.py

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

capo_lambda/types/integer.py

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

capo_lambda/types/invocation_completed_details.py

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

capo_lambda/types/invocation_request.py

@@ -0,0 +1,57 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#InvocationRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.blob
+    import capo_lambda.types.durable_execution_name
+    import capo_lambda.types.invocation_type
+    import capo_lambda.types.log_type
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+    import capo_lambda.types.string
+    import capo_lambda.types.tenant_id
+
+
+class InvocationRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    r"""<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>"""
+    invocation_type: NotRequired["capo_lambda.types.invocation_type.InvocationType"]
+    """<p>Choose from the following options.</p> <ul> <li> <p> <code>RequestResponse</code> (default) – Invoke the function synchronously. Keep the connection open until the function returns a response or times out. The API response includes the function response and additional data.</p> </li> <li> <p> <code>Event</code> – Invoke the function asynchronously. Send events that fail multiple times to the function's dead-letter queue (if one is configured). The API response only includes a status code.</p> </li> <li> <p> <code>DryRun</code> – Validate parameter values and verify that the user or role has permission to invoke the function.</p> </li> </ul>"""
+    log_type: NotRequired["capo_lambda.types.log_type.LogType"]
+    """<p>Set to <code>Tail</code> to include the execution log in the response. Applies to synchronously invoked functions only.</p>"""
+    client_context: NotRequired["capo_lambda.types.string.String"]
+    """<p>Up to 3,583 bytes of base64-encoded data about the invoking client to pass to the function in the context object. Lambda passes the <code>ClientContext</code> object to your function for synchronous invocations only.</p>"""
+    durable_execution_name: NotRequired[
+        "capo_lambda.types.durable_execution_name.DurableExecutionName"
+    ]
+    """<p>Optional unique name for the durable execution. When you start your special function, you can give it a unique name to identify this specific execution. It's like giving a nickname to a task.</p>"""
+    payload: NotRequired["capo_lambda.types.blob.Blob"]
+    r"""<p>The JSON that you want to provide to your Lambda function as input. The maximum payload size is 6 MB for synchronous invocations and 1 MB for asynchronous invocations.</p> <p>You can enter the JSON directly. For example, <code>--payload '{ \"key\": \"value\" }'</code>. You can also specify a file path. For example, <code>--payload file://payload.json</code>.</p>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version or alias to invoke a published version of the function.</p>"""
+    tenant_id: NotRequired["capo_lambda.types.tenant_id.TenantId"]
+    """<p>The identifier of the tenant in a multi-tenant Lambda function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: InvocationRequest) -> dict:
+    out: dict = {}
+    if "payload" in value:
+        import capo_lambda.types.blob
+
+        out["Payload"] = capo_lambda.types.blob.serialize_json(value["payload"])
+    return out
+
+
+def deserialize_json(data: dict) -> InvocationRequest:
+    out: InvocationRequest = {}  # type: ignore[typeddict-item]
+    if "Payload" in data:
+        import capo_lambda.types.blob
+
+        out["payload"] = capo_lambda.types.blob.deserialize_json(data["Payload"])
+    return out