capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/function_response_type.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionResponseType``."""
+
+from typing import Literal, TypeAlias, cast
+
+FunctionResponseType: TypeAlias = Literal["ReportBatchItemFailures",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionResponseType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> FunctionResponseType:
+    return cast(FunctionResponseType, data)

capo_lambda/types/function_response_type_list.py

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

capo_lambda/types/function_scaling_config.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionScalingConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_scaling_config_execution_environments
+
+
+class FunctionScalingConfig(TypedDict, closed=True):
+    min_execution_environments: NotRequired[
+        "capo_lambda.types.function_scaling_config_execution_environments.FunctionScalingConfigExecutionEnvironments"
+    ]
+    """<p>The minimum number of execution environments to maintain for the function.</p>"""
+    max_execution_environments: NotRequired[
+        "capo_lambda.types.function_scaling_config_execution_environments.FunctionScalingConfigExecutionEnvironments"
+    ]
+    """<p>The maximum number of execution environments that can be provisioned for the function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionScalingConfig) -> dict:
+    out: dict = {}
+    if "min_execution_environments" in value:
+        out["MinExecutionEnvironments"] = value["min_execution_environments"]
+    if "max_execution_environments" in value:
+        out["MaxExecutionEnvironments"] = value["max_execution_environments"]
+    return out
+
+
+def deserialize_json(data: dict) -> FunctionScalingConfig:
+    out: FunctionScalingConfig = {}  # type: ignore[typeddict-item]
+    if "MinExecutionEnvironments" in data:
+        out["min_execution_environments"] = data["MinExecutionEnvironments"]
+    if "MaxExecutionEnvironments" in data:
+        out["max_execution_environments"] = data["MaxExecutionEnvironments"]
+    return out

capo_lambda/types/function_scaling_config_execution_environments.py

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

capo_lambda/types/function_url.py

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

capo_lambda/types/function_url_auth_type.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionUrlAuthType``."""
+
+from typing import Literal, TypeAlias, cast
+
+FunctionUrlAuthType: TypeAlias = Literal[
+    "NONE",
+    "AWS_IAM",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionUrlAuthType) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> FunctionUrlAuthType:
+    return cast(FunctionUrlAuthType, data)

capo_lambda/types/function_url_config.py

@@ -0,0 +1,96 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionUrlConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.cors
+    import capo_lambda.types.function_arn
+    import capo_lambda.types.function_url
+    import capo_lambda.types.function_url_auth_type
+    import capo_lambda.types.invoke_mode
+    import capo_lambda.types.timestamp
+
+
+class FunctionUrlConfig(TypedDict, closed=True):
+    function_url: "capo_lambda.types.function_url.FunctionUrl"
+    """<p>The HTTP URL endpoint for your function.</p>"""
+    function_arn: "capo_lambda.types.function_arn.FunctionArn"
+    """<p>The Amazon Resource Name (ARN) of your function.</p>"""
+    creation_time: "capo_lambda.types.timestamp.Timestamp"
+    r"""<p>When the function URL was created, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    last_modified_time: "capo_lambda.types.timestamp.Timestamp"
+    r"""<p>When the function URL configuration was last updated, in <a href=\"https://www.w3.org/TR/NOTE-datetime\">ISO-8601 format</a> (YYYY-MM-DDThh:mm:ss.sTZD).</p>"""
+    cors: NotRequired["capo_lambda.types.cors.Cors"]
+    r"""<p>The <a href=\"https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS\">cross-origin resource sharing (CORS)</a> settings for your function URL.</p>"""
+    auth_type: "capo_lambda.types.function_url_auth_type.FunctionUrlAuthType"
+    r"""<p>The type of authentication that your function URL uses. Set to <code>AWS_IAM</code> if you want to restrict access to authenticated users only. Set to <code>NONE</code> if you want to bypass IAM authentication to create a public endpoint. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html\">Security and auth model for Lambda function URLs</a>.</p>"""
+    invoke_mode: NotRequired["capo_lambda.types.invoke_mode.InvokeMode"]
+    """<p>Use one of the following options:</p> <ul> <li> <p> <code>BUFFERED</code> – This is the default option. Lambda invokes your function using the <code>Invoke</code> API operation. Invocation results are available when the payload is complete. The maximum payload size is 6 MB.</p> </li> <li> <p> <code>RESPONSE_STREAM</code> – Your function streams payload results as they become available. Lambda invokes your function using the <code>InvokeWithResponseStream</code> API operation. The maximum response payload size is 200 MB.</p> </li> </ul>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionUrlConfig) -> dict:
+    out: dict = {}
+    out["FunctionUrl"] = value["function_url"]
+    out["FunctionArn"] = value["function_arn"]
+    out["CreationTime"] = value["creation_time"]
+    out["LastModifiedTime"] = value["last_modified_time"]
+    if "cors" in value:
+        import capo_lambda.types.cors
+
+        out["Cors"] = capo_lambda.types.cors.serialize_json(value["cors"])
+    import capo_lambda.types.function_url_auth_type
+
+    out["AuthType"] = capo_lambda.types.function_url_auth_type.serialize_json(
+        value["auth_type"]
+    )
+    if "invoke_mode" in value:
+        import capo_lambda.types.invoke_mode
+
+        out["InvokeMode"] = capo_lambda.types.invoke_mode.serialize_json(
+            value["invoke_mode"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> FunctionUrlConfig:
+    out: FunctionUrlConfig = {}  # type: ignore[typeddict-item]
+    if "FunctionUrl" in data:
+        out["function_url"] = data["FunctionUrl"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.function_url required")
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.function_arn required")
+    if "CreationTime" in data:
+        out["creation_time"] = data["CreationTime"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.creation_time required")
+    if "LastModifiedTime" in data:
+        out["last_modified_time"] = data["LastModifiedTime"]
+    else:
+        raise DeserializationError("FunctionUrlConfig.last_modified_time required")
+    if "Cors" in data:
+        import capo_lambda.types.cors
+
+        out["cors"] = capo_lambda.types.cors.deserialize_json(data["Cors"])
+    if "AuthType" in data:
+        import capo_lambda.types.function_url_auth_type
+
+        out["auth_type"] = capo_lambda.types.function_url_auth_type.deserialize_json(
+            data["AuthType"]
+        )
+    else:
+        raise DeserializationError("FunctionUrlConfig.auth_type required")
+    if "InvokeMode" in data:
+        import capo_lambda.types.invoke_mode
+
+        out["invoke_mode"] = capo_lambda.types.invoke_mode.deserialize_json(
+            data["InvokeMode"]
+        )
+    return out

capo_lambda/types/function_url_config_list.py

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

capo_lambda/types/function_url_qualifier.py

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

capo_lambda/types/function_version.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionVersion``."""
+
+from typing import Literal, TypeAlias, cast
+
+FunctionVersion: TypeAlias = Literal["ALL",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionVersion) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> FunctionVersion:
+    return cast(FunctionVersion, data)

capo_lambda/types/function_version_latest_published.py

@@ -0,0 +1,14 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionVersionLatestPublished``."""
+
+from typing import Literal, TypeAlias, cast
+
+FunctionVersionLatestPublished: TypeAlias = Literal["LATEST_PUBLISHED",]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionVersionLatestPublished) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> FunctionVersionLatestPublished:
+    return cast(FunctionVersionLatestPublished, data)

capo_lambda/types/function_versions_by_capacity_provider_list.py

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

capo_lambda/types/function_versions_by_capacity_provider_list_item.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#FunctionVersionsByCapacityProviderListItem``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.name_spaced_function_arn
+    import capo_lambda.types.state
+
+
+class FunctionVersionsByCapacityProviderListItem(TypedDict, closed=True):
+    function_arn: "capo_lambda.types.name_spaced_function_arn.NameSpacedFunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the function version.</p>"""
+    state: "capo_lambda.types.state.State"
+    """<p>The current state of the function version.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: FunctionVersionsByCapacityProviderListItem) -> dict:
+    out: dict = {}
+    out["FunctionArn"] = value["function_arn"]
+    import capo_lambda.types.state
+
+    out["State"] = capo_lambda.types.state.serialize_json(value["state"])
+    return out
+
+
+def deserialize_json(data: dict) -> FunctionVersionsByCapacityProviderListItem:
+    out: FunctionVersionsByCapacityProviderListItem = {}  # type: ignore[typeddict-item]
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    else:
+        raise DeserializationError(
+            "FunctionVersionsByCapacityProviderListItem.function_arn required"
+        )
+    if "State" in data:
+        import capo_lambda.types.state
+
+        out["state"] = capo_lambda.types.state.deserialize_json(data["State"])
+    else:
+        raise DeserializationError(
+            "FunctionVersionsByCapacityProviderListItem.state required"
+        )
+    return out

capo_lambda/types/get_account_settings_request.py

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

capo_lambda/types/get_account_settings_response.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetAccountSettingsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.account_limit
+    import capo_lambda.types.account_usage
+
+
+class GetAccountSettingsResponse(TypedDict, closed=True):
+    account_limit: NotRequired["capo_lambda.types.account_limit.AccountLimit"]
+    """<p>Limits that are related to concurrency and code storage.</p>"""
+    account_usage: NotRequired["capo_lambda.types.account_usage.AccountUsage"]
+    """<p>The number of functions and amount of storage in use.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAccountSettingsResponse) -> dict:
+    out: dict = {}
+    if "account_limit" in value:
+        import capo_lambda.types.account_limit
+
+        out["AccountLimit"] = capo_lambda.types.account_limit.serialize_json(
+            value["account_limit"]
+        )
+    if "account_usage" in value:
+        import capo_lambda.types.account_usage
+
+        out["AccountUsage"] = capo_lambda.types.account_usage.serialize_json(
+            value["account_usage"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> GetAccountSettingsResponse:
+    out: GetAccountSettingsResponse = {}  # type: ignore[typeddict-item]
+    if "AccountLimit" in data:
+        import capo_lambda.types.account_limit
+
+        out["account_limit"] = capo_lambda.types.account_limit.deserialize_json(
+            data["AccountLimit"]
+        )
+    if "AccountUsage" in data:
+        import capo_lambda.types.account_usage
+
+        out["account_usage"] = capo_lambda.types.account_usage.deserialize_json(
+            data["AccountUsage"]
+        )
+    return out

capo_lambda/types/get_alias_request.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetAliasRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.alias
+    import capo_lambda.types.function_name
+
+
+class GetAliasRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.function_name.FunctionName"
+    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>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>"""
+    name: "capo_lambda.types.alias.Alias"
+    """<p>The name of the alias.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetAliasRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetAliasRequest:
+    out: GetAliasRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/get_capacity_provider_request.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCapacityProviderRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_name
+
+
+class GetCapacityProviderRequest(TypedDict, closed=True):
+    capacity_provider_name: (
+        "capo_lambda.types.capacity_provider_name.CapacityProviderName"
+    )
+    """<p>The name of the capacity provider to retrieve.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCapacityProviderRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetCapacityProviderRequest:
+    out: GetCapacityProviderRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/get_capacity_provider_response.py

@@ -0,0 +1,41 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCapacityProviderResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider
+
+
+class GetCapacityProviderResponse(TypedDict, closed=True):
+    capacity_provider: "capo_lambda.types.capacity_provider.CapacityProvider"
+    """<p>Information about the capacity provider, including its configuration and current state.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCapacityProviderResponse) -> dict:
+    out: dict = {}
+    import capo_lambda.types.capacity_provider
+
+    out["CapacityProvider"] = capo_lambda.types.capacity_provider.serialize_json(
+        value["capacity_provider"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetCapacityProviderResponse:
+    out: GetCapacityProviderResponse = {}  # type: ignore[typeddict-item]
+    if "CapacityProvider" in data:
+        import capo_lambda.types.capacity_provider
+
+        out["capacity_provider"] = capo_lambda.types.capacity_provider.deserialize_json(
+            data["CapacityProvider"]
+        )
+    else:
+        raise DeserializationError(
+            "GetCapacityProviderResponse.capacity_provider required"
+        )
+    return out

capo_lambda/types/get_code_signing_config_request.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCodeSigningConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.code_signing_config_arn
+
+
+class GetCodeSigningConfigRequest(TypedDict, closed=True):
+    code_signing_config_arn: (
+        "capo_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCodeSigningConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetCodeSigningConfigRequest:
+    out: GetCodeSigningConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/get_code_signing_config_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetCodeSigningConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.code_signing_config
+
+
+class GetCodeSigningConfigResponse(TypedDict, closed=True):
+    code_signing_config: "capo_lambda.types.code_signing_config.CodeSigningConfig"
+    """<p>The code signing configuration</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetCodeSigningConfigResponse) -> dict:
+    out: dict = {}
+    import capo_lambda.types.code_signing_config
+
+    out["CodeSigningConfig"] = capo_lambda.types.code_signing_config.serialize_json(
+        value["code_signing_config"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetCodeSigningConfigResponse:
+    out: GetCodeSigningConfigResponse = {}  # type: ignore[typeddict-item]
+    if "CodeSigningConfig" in data:
+        import capo_lambda.types.code_signing_config
+
+        out["code_signing_config"] = (
+            capo_lambda.types.code_signing_config.deserialize_json(
+                data["CodeSigningConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "GetCodeSigningConfigResponse.code_signing_config required"
+        )
+    return out

capo_lambda/types/get_durable_execution_history_request.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#GetDurableExecutionHistoryRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.durable_execution_arn
+    import capo_lambda.types.include_execution_data
+    import capo_lambda.types.item_count
+    import capo_lambda.types.reverse_order
+    import capo_lambda.types.string
+
+
+class GetDurableExecutionHistoryRequest(TypedDict, closed=True):
+    durable_execution_arn: "capo_lambda.types.durable_execution_arn.DurableExecutionArn"
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    include_execution_data: NotRequired[
+        "capo_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: "capo_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["capo_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["capo_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