capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/callback_timed_out_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackTimedOutDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.event_error
+
+
+class CallbackTimedOutDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about the callback timeout.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackTimedOutDetails) -> dict:
+    out: dict = {}
+    import capo_lambda.types.event_error
+
+    out["Error"] = capo_lambda.types.event_error.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackTimedOutDetails:
+    out: CallbackTimedOutDetails = {}  # type: ignore[typeddict-item]
+    if "Error" in data:
+        import capo_lambda.types.event_error
+
+        out["error"] = capo_lambda.types.event_error.deserialize_json(data["Error"])
+    else:
+        raise DeserializationError("CallbackTimedOutDetails.error required")
+    return out

capo_lambda/types/capacity_provider.py

@@ -0,0 +1,143 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProvider``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_arn
+    import capo_lambda.types.capacity_provider_permissions_config
+    import capo_lambda.types.capacity_provider_scaling_config
+    import capo_lambda.types.capacity_provider_state
+    import capo_lambda.types.capacity_provider_vpc_config
+    import capo_lambda.types.instance_requirements
+    import capo_lambda.types.kms_key_arn
+    import capo_lambda.types.timestamp
+
+
+class CapacityProvider(TypedDict, closed=True):
+    capacity_provider_arn: "capo_lambda.types.capacity_provider_arn.CapacityProviderArn"
+    """<p>The Amazon Resource Name (ARN) of the capacity provider.</p>"""
+    state: "capo_lambda.types.capacity_provider_state.CapacityProviderState"
+    """<p>The current state of the capacity provider.</p>"""
+    vpc_config: (
+        "capo_lambda.types.capacity_provider_vpc_config.CapacityProviderVpcConfig"
+    )
+    """<p>The VPC configuration for the capacity provider.</p>"""
+    permissions_config: "capo_lambda.types.capacity_provider_permissions_config.CapacityProviderPermissionsConfig"
+    """<p>The permissions configuration for the capacity provider.</p>"""
+    instance_requirements: NotRequired[
+        "capo_lambda.types.instance_requirements.InstanceRequirements"
+    ]
+    """<p>The instance requirements for compute resources managed by the capacity provider.</p>"""
+    capacity_provider_scaling_config: NotRequired[
+        "capo_lambda.types.capacity_provider_scaling_config.CapacityProviderScalingConfig"
+    ]
+    """<p>The scaling configuration for the capacity provider.</p>"""
+    kms_key_arn: NotRequired["capo_lambda.types.kms_key_arn.KMSKeyArn"]
+    """<p>The ARN of the KMS key used to encrypt the capacity provider's resources.</p>"""
+    last_modified: NotRequired["capo_lambda.types.timestamp.Timestamp"]
+    """<p>The date and time when the capacity provider was last modified.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProvider) -> dict:
+    out: dict = {}
+    out["CapacityProviderArn"] = value["capacity_provider_arn"]
+    import capo_lambda.types.capacity_provider_state
+
+    out["State"] = capo_lambda.types.capacity_provider_state.serialize_json(
+        value["state"]
+    )
+    import capo_lambda.types.capacity_provider_vpc_config
+
+    out["VpcConfig"] = capo_lambda.types.capacity_provider_vpc_config.serialize_json(
+        value["vpc_config"]
+    )
+    import capo_lambda.types.capacity_provider_permissions_config
+
+    out["PermissionsConfig"] = (
+        capo_lambda.types.capacity_provider_permissions_config.serialize_json(
+            value["permissions_config"]
+        )
+    )
+    if "instance_requirements" in value:
+        import capo_lambda.types.instance_requirements
+
+        out["InstanceRequirements"] = (
+            capo_lambda.types.instance_requirements.serialize_json(
+                value["instance_requirements"]
+            )
+        )
+    if "capacity_provider_scaling_config" in value:
+        import capo_lambda.types.capacity_provider_scaling_config
+
+        out["CapacityProviderScalingConfig"] = (
+            capo_lambda.types.capacity_provider_scaling_config.serialize_json(
+                value["capacity_provider_scaling_config"]
+            )
+        )
+    if "kms_key_arn" in value:
+        out["KmsKeyArn"] = value["kms_key_arn"]
+    if "last_modified" in value:
+        out["LastModified"] = value["last_modified"]
+    return out
+
+
+def deserialize_json(data: dict) -> CapacityProvider:
+    out: CapacityProvider = {}  # type: ignore[typeddict-item]
+    if "CapacityProviderArn" in data:
+        out["capacity_provider_arn"] = data["CapacityProviderArn"]
+    else:
+        raise DeserializationError("CapacityProvider.capacity_provider_arn required")
+    if "State" in data:
+        import capo_lambda.types.capacity_provider_state
+
+        out["state"] = capo_lambda.types.capacity_provider_state.deserialize_json(
+            data["State"]
+        )
+    else:
+        raise DeserializationError("CapacityProvider.state required")
+    if "VpcConfig" in data:
+        import capo_lambda.types.capacity_provider_vpc_config
+
+        out["vpc_config"] = (
+            capo_lambda.types.capacity_provider_vpc_config.deserialize_json(
+                data["VpcConfig"]
+            )
+        )
+    else:
+        raise DeserializationError("CapacityProvider.vpc_config required")
+    if "PermissionsConfig" in data:
+        import capo_lambda.types.capacity_provider_permissions_config
+
+        out["permissions_config"] = (
+            capo_lambda.types.capacity_provider_permissions_config.deserialize_json(
+                data["PermissionsConfig"]
+            )
+        )
+    else:
+        raise DeserializationError("CapacityProvider.permissions_config required")
+    if "InstanceRequirements" in data:
+        import capo_lambda.types.instance_requirements
+
+        out["instance_requirements"] = (
+            capo_lambda.types.instance_requirements.deserialize_json(
+                data["InstanceRequirements"]
+            )
+        )
+    if "CapacityProviderScalingConfig" in data:
+        import capo_lambda.types.capacity_provider_scaling_config
+
+        out["capacity_provider_scaling_config"] = (
+            capo_lambda.types.capacity_provider_scaling_config.deserialize_json(
+                data["CapacityProviderScalingConfig"]
+            )
+        )
+    if "KmsKeyArn" in data:
+        out["kms_key_arn"] = data["KmsKeyArn"]
+    if "LastModified" in data:
+        out["last_modified"] = data["LastModified"]
+    return out

capo_lambda/types/capacity_provider_arn.py

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

capo_lambda/types/capacity_provider_config.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.lambda_managed_instances_capacity_provider_config
+
+
+class CapacityProviderConfig(TypedDict, closed=True):
+    lambda_managed_instances_capacity_provider_config: "capo_lambda.types.lambda_managed_instances_capacity_provider_config.LambdaManagedInstancesCapacityProviderConfig"
+    """<p>Configuration for Lambda-managed instances used by the capacity provider.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProviderConfig) -> dict:
+    out: dict = {}
+    import capo_lambda.types.lambda_managed_instances_capacity_provider_config
+
+    out["LambdaManagedInstancesCapacityProviderConfig"] = (
+        capo_lambda.types.lambda_managed_instances_capacity_provider_config.serialize_json(
+            value["lambda_managed_instances_capacity_provider_config"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> CapacityProviderConfig:
+    out: CapacityProviderConfig = {}  # type: ignore[typeddict-item]
+    if "LambdaManagedInstancesCapacityProviderConfig" in data:
+        import capo_lambda.types.lambda_managed_instances_capacity_provider_config
+
+        out["lambda_managed_instances_capacity_provider_config"] = (
+            capo_lambda.types.lambda_managed_instances_capacity_provider_config.deserialize_json(
+                data["LambdaManagedInstancesCapacityProviderConfig"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CapacityProviderConfig.lambda_managed_instances_capacity_provider_config required"
+        )
+    return out

capo_lambda/types/capacity_provider_max_v_cpu_count.py

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

capo_lambda/types/capacity_provider_name.py

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

capo_lambda/types/capacity_provider_permissions_config.py

@@ -0,0 +1,37 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderPermissionsConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.role_arn
+
+
+class CapacityProviderPermissionsConfig(TypedDict, closed=True):
+    capacity_provider_operator_role_arn: "capo_lambda.types.role_arn.RoleArn"
+    """<p>The ARN of the IAM role that the capacity provider uses to manage compute instances and other Amazon Web Services resources.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProviderPermissionsConfig) -> dict:
+    out: dict = {}
+    out["CapacityProviderOperatorRoleArn"] = value[
+        "capacity_provider_operator_role_arn"
+    ]
+    return out
+
+
+def deserialize_json(data: dict) -> CapacityProviderPermissionsConfig:
+    out: CapacityProviderPermissionsConfig = {}  # type: ignore[typeddict-item]
+    if "CapacityProviderOperatorRoleArn" in data:
+        out["capacity_provider_operator_role_arn"] = data[
+            "CapacityProviderOperatorRoleArn"
+        ]
+    else:
+        raise DeserializationError(
+            "CapacityProviderPermissionsConfig.capacity_provider_operator_role_arn required"
+        )
+    return out

capo_lambda/types/capacity_provider_predefined_metric_type.py

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

capo_lambda/types/capacity_provider_scaling_config.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderScalingConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_max_v_cpu_count
+    import capo_lambda.types.capacity_provider_scaling_mode
+    import capo_lambda.types.capacity_provider_scaling_policies_list
+
+
+class CapacityProviderScalingConfig(TypedDict, closed=True):
+    max_v_cpu_count: NotRequired[
+        "capo_lambda.types.capacity_provider_max_v_cpu_count.CapacityProviderMaxVCpuCount"
+    ]
+    """<p>The maximum number of vCPUs that the capacity provider can provision across all compute instances.</p>"""
+    scaling_mode: NotRequired[
+        "capo_lambda.types.capacity_provider_scaling_mode.CapacityProviderScalingMode"
+    ]
+    """<p>The scaling mode that determines how the capacity provider responds to changes in demand.</p>"""
+    scaling_policies: NotRequired[
+        "capo_lambda.types.capacity_provider_scaling_policies_list.CapacityProviderScalingPoliciesList"
+    ]
+    """<p>A list of scaling policies that define how the capacity provider scales compute instances based on metrics and thresholds.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProviderScalingConfig) -> dict:
+    out: dict = {}
+    if "max_v_cpu_count" in value:
+        out["MaxVCpuCount"] = value["max_v_cpu_count"]
+    if "scaling_mode" in value:
+        import capo_lambda.types.capacity_provider_scaling_mode
+
+        out["ScalingMode"] = (
+            capo_lambda.types.capacity_provider_scaling_mode.serialize_json(
+                value["scaling_mode"]
+            )
+        )
+    if "scaling_policies" in value:
+        import capo_lambda.types.capacity_provider_scaling_policies_list
+
+        out["ScalingPolicies"] = (
+            capo_lambda.types.capacity_provider_scaling_policies_list.serialize_json(
+                value["scaling_policies"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> CapacityProviderScalingConfig:
+    out: CapacityProviderScalingConfig = {}  # type: ignore[typeddict-item]
+    if "MaxVCpuCount" in data:
+        out["max_v_cpu_count"] = data["MaxVCpuCount"]
+    if "ScalingMode" in data:
+        import capo_lambda.types.capacity_provider_scaling_mode
+
+        out["scaling_mode"] = (
+            capo_lambda.types.capacity_provider_scaling_mode.deserialize_json(
+                data["ScalingMode"]
+            )
+        )
+    if "ScalingPolicies" in data:
+        import capo_lambda.types.capacity_provider_scaling_policies_list
+
+        out["scaling_policies"] = (
+            capo_lambda.types.capacity_provider_scaling_policies_list.deserialize_json(
+                data["ScalingPolicies"]
+            )
+        )
+    return out

capo_lambda/types/capacity_provider_scaling_mode.py

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

capo_lambda/types/capacity_provider_scaling_policies_list.py

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

capo_lambda/types/capacity_provider_security_group_ids.py

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

capo_lambda/types/capacity_provider_state.py

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

capo_lambda/types/capacity_provider_subnet_ids.py

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

capo_lambda/types/capacity_provider_vpc_config.py

@@ -0,0 +1,65 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderVpcConfig``."""
+
+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_security_group_ids
+    import capo_lambda.types.capacity_provider_subnet_ids
+
+
+class CapacityProviderVpcConfig(TypedDict, closed=True):
+    subnet_ids: (
+        "capo_lambda.types.capacity_provider_subnet_ids.CapacityProviderSubnetIds"
+    )
+    """<p>A list of subnet IDs where the capacity provider launches compute instances.</p>"""
+    security_group_ids: "capo_lambda.types.capacity_provider_security_group_ids.CapacityProviderSecurityGroupIds"
+    """<p>A list of security group IDs that control network access for compute instances managed by the capacity provider.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProviderVpcConfig) -> dict:
+    out: dict = {}
+    import capo_lambda.types.capacity_provider_subnet_ids
+
+    out["SubnetIds"] = capo_lambda.types.capacity_provider_subnet_ids.serialize_json(
+        value["subnet_ids"]
+    )
+    import capo_lambda.types.capacity_provider_security_group_ids
+
+    out["SecurityGroupIds"] = (
+        capo_lambda.types.capacity_provider_security_group_ids.serialize_json(
+            value["security_group_ids"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> CapacityProviderVpcConfig:
+    out: CapacityProviderVpcConfig = {}  # type: ignore[typeddict-item]
+    if "SubnetIds" in data:
+        import capo_lambda.types.capacity_provider_subnet_ids
+
+        out["subnet_ids"] = (
+            capo_lambda.types.capacity_provider_subnet_ids.deserialize_json(
+                data["SubnetIds"]
+            )
+        )
+    else:
+        raise DeserializationError("CapacityProviderVpcConfig.subnet_ids required")
+    if "SecurityGroupIds" in data:
+        import capo_lambda.types.capacity_provider_security_group_ids
+
+        out["security_group_ids"] = (
+            capo_lambda.types.capacity_provider_security_group_ids.deserialize_json(
+                data["SecurityGroupIds"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CapacityProviderVpcConfig.security_group_ids required"
+        )
+    return out

capo_lambda/types/capacity_providers_list.py

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

capo_lambda/types/chained_invoke_details.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ChainedInvokeDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.error_object
+    import capo_lambda.types.operation_payload
+
+
+class ChainedInvokeDetails(TypedDict, closed=True):
+    result: NotRequired["capo_lambda.types.operation_payload.OperationPayload"]
+    """<p>The response payload from the chained invocation.</p>"""
+    error: NotRequired["capo_lambda.types.error_object.ErrorObject"]
+    """<p>Details about the chained invocation failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ChainedInvokeDetails) -> dict:
+    out: dict = {}
+    if "result" in value:
+        out["Result"] = value["result"]
+    if "error" in value:
+        import capo_lambda.types.error_object
+
+        out["Error"] = capo_lambda.types.error_object.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> ChainedInvokeDetails:
+    out: ChainedInvokeDetails = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        out["result"] = data["Result"]
+    if "Error" in data:
+        import capo_lambda.types.error_object
+
+        out["error"] = capo_lambda.types.error_object.deserialize_json(data["Error"])
+    return out

capo_lambda/types/chained_invoke_failed_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ChainedInvokeFailedDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.event_error
+
+
+class ChainedInvokeFailedDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about the chained invocation failure.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ChainedInvokeFailedDetails) -> dict:
+    out: dict = {}
+    import capo_lambda.types.event_error
+
+    out["Error"] = capo_lambda.types.event_error.serialize_json(value["error"])
+    return out
+
+
+def deserialize_json(data: dict) -> ChainedInvokeFailedDetails:
+    out: ChainedInvokeFailedDetails = {}  # type: ignore[typeddict-item]
+    if "Error" in data:
+        import capo_lambda.types.event_error
+
+        out["error"] = capo_lambda.types.event_error.deserialize_json(data["Error"])
+    else:
+        raise DeserializationError("ChainedInvokeFailedDetails.error required")
+    return out