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

aws_sdk_lambda/types/callback_succeeded_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CallbackSucceededDetails``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.event_result
+
+
+class CallbackSucceededDetails(TypedDict):
+    result: "aws_sdk_lambda.types.event_result.EventResult"
+    """<p>The response payload from the successful operation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CallbackSucceededDetails) -> dict:
+    out: dict = {}
+    import aws_sdk_lambda.types.event_result
+
+    out["Result"] = aws_sdk_lambda.types.event_result.serialize_json(value["result"])
+    return out
+
+
+def deserialize_json(data: dict) -> CallbackSucceededDetails:
+    out: CallbackSucceededDetails = {}  # type: ignore[typeddict-item]
+    if "Result" in data:
+        import aws_sdk_lambda.types.event_result
+
+        out["result"] = aws_sdk_lambda.types.event_result.deserialize_json(
+            data["Result"]
+        )
+    else:
+        raise DeserializationError("CallbackSucceededDetails.result required")
+    return out

aws_sdk_lambda/types/callback_timed_out_details.py

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

aws_sdk_lambda/types/capacity_provider.py

@@ -0,0 +1,145 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProvider``."""
+
+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.capacity_provider_arn
+    import aws_sdk_lambda.types.capacity_provider_permissions_config
+    import aws_sdk_lambda.types.capacity_provider_scaling_config
+    import aws_sdk_lambda.types.capacity_provider_state
+    import aws_sdk_lambda.types.capacity_provider_vpc_config
+    import aws_sdk_lambda.types.instance_requirements
+    import aws_sdk_lambda.types.kms_key_arn
+    import aws_sdk_lambda.types.timestamp
+
+
+class CapacityProvider(TypedDict):
+    capacity_provider_arn: (
+        "aws_sdk_lambda.types.capacity_provider_arn.CapacityProviderArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the capacity provider.</p>"""
+    state: "aws_sdk_lambda.types.capacity_provider_state.CapacityProviderState"
+    """<p>The current state of the capacity provider.</p>"""
+    vpc_config: (
+        "aws_sdk_lambda.types.capacity_provider_vpc_config.CapacityProviderVpcConfig"
+    )
+    """<p>The VPC configuration for the capacity provider.</p>"""
+    permissions_config: "aws_sdk_lambda.types.capacity_provider_permissions_config.CapacityProviderPermissionsConfig"
+    """<p>The permissions configuration for the capacity provider.</p>"""
+    instance_requirements: NotRequired[
+        "aws_sdk_lambda.types.instance_requirements.InstanceRequirements"
+    ]
+    """<p>The instance requirements for compute resources managed by the capacity provider.</p>"""
+    capacity_provider_scaling_config: NotRequired[
+        "aws_sdk_lambda.types.capacity_provider_scaling_config.CapacityProviderScalingConfig"
+    ]
+    """<p>The scaling configuration for the capacity provider.</p>"""
+    kms_key_arn: NotRequired["aws_sdk_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["aws_sdk_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 aws_sdk_lambda.types.capacity_provider_state
+
+    out["State"] = aws_sdk_lambda.types.capacity_provider_state.serialize_json(
+        value["state"]
+    )
+    import aws_sdk_lambda.types.capacity_provider_vpc_config
+
+    out["VpcConfig"] = aws_sdk_lambda.types.capacity_provider_vpc_config.serialize_json(
+        value["vpc_config"]
+    )
+    import aws_sdk_lambda.types.capacity_provider_permissions_config
+
+    out["PermissionsConfig"] = (
+        aws_sdk_lambda.types.capacity_provider_permissions_config.serialize_json(
+            value["permissions_config"]
+        )
+    )
+    if "instance_requirements" in value:
+        import aws_sdk_lambda.types.instance_requirements
+
+        out["InstanceRequirements"] = (
+            aws_sdk_lambda.types.instance_requirements.serialize_json(
+                value["instance_requirements"]
+            )
+        )
+    if "capacity_provider_scaling_config" in value:
+        import aws_sdk_lambda.types.capacity_provider_scaling_config
+
+        out["CapacityProviderScalingConfig"] = (
+            aws_sdk_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 aws_sdk_lambda.types.capacity_provider_state
+
+        out["state"] = aws_sdk_lambda.types.capacity_provider_state.deserialize_json(
+            data["State"]
+        )
+    else:
+        raise DeserializationError("CapacityProvider.state required")
+    if "VpcConfig" in data:
+        import aws_sdk_lambda.types.capacity_provider_vpc_config
+
+        out["vpc_config"] = (
+            aws_sdk_lambda.types.capacity_provider_vpc_config.deserialize_json(
+                data["VpcConfig"]
+            )
+        )
+    else:
+        raise DeserializationError("CapacityProvider.vpc_config required")
+    if "PermissionsConfig" in data:
+        import aws_sdk_lambda.types.capacity_provider_permissions_config
+
+        out["permissions_config"] = (
+            aws_sdk_lambda.types.capacity_provider_permissions_config.deserialize_json(
+                data["PermissionsConfig"]
+            )
+        )
+    else:
+        raise DeserializationError("CapacityProvider.permissions_config required")
+    if "InstanceRequirements" in data:
+        import aws_sdk_lambda.types.instance_requirements
+
+        out["instance_requirements"] = (
+            aws_sdk_lambda.types.instance_requirements.deserialize_json(
+                data["InstanceRequirements"]
+            )
+        )
+    if "CapacityProviderScalingConfig" in data:
+        import aws_sdk_lambda.types.capacity_provider_scaling_config
+
+        out["capacity_provider_scaling_config"] = (
+            aws_sdk_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

aws_sdk_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

aws_sdk_lambda/types/capacity_provider_config.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.lambda_managed_instances_capacity_provider_config
+
+
+class CapacityProviderConfig(TypedDict):
+    lambda_managed_instances_capacity_provider_config: "aws_sdk_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 aws_sdk_lambda.types.lambda_managed_instances_capacity_provider_config
+
+    out["LambdaManagedInstancesCapacityProviderConfig"] = (
+        aws_sdk_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 aws_sdk_lambda.types.lambda_managed_instances_capacity_provider_config
+
+        out["lambda_managed_instances_capacity_provider_config"] = (
+            aws_sdk_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

aws_sdk_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

aws_sdk_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

aws_sdk_lambda/types/capacity_provider_permissions_config.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderPermissionsConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.role_arn
+
+
+class CapacityProviderPermissionsConfig(TypedDict):
+    capacity_provider_operator_role_arn: "aws_sdk_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

aws_sdk_lambda/types/capacity_provider_predefined_metric_type.py

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

aws_sdk_lambda/types/capacity_provider_scaling_config.py

@@ -0,0 +1,72 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderScalingConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.capacity_provider_max_v_cpu_count
+    import aws_sdk_lambda.types.capacity_provider_scaling_mode
+    import aws_sdk_lambda.types.capacity_provider_scaling_policies_list
+
+
+class CapacityProviderScalingConfig(TypedDict):
+    max_v_cpu_count: NotRequired[
+        "aws_sdk_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[
+        "aws_sdk_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[
+        "aws_sdk_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 aws_sdk_lambda.types.capacity_provider_scaling_mode
+
+        out["ScalingMode"] = (
+            aws_sdk_lambda.types.capacity_provider_scaling_mode.serialize_json(
+                value["scaling_mode"]
+            )
+        )
+    if "scaling_policies" in value:
+        import aws_sdk_lambda.types.capacity_provider_scaling_policies_list
+
+        out["ScalingPolicies"] = (
+            aws_sdk_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 aws_sdk_lambda.types.capacity_provider_scaling_mode
+
+        out["scaling_mode"] = (
+            aws_sdk_lambda.types.capacity_provider_scaling_mode.deserialize_json(
+                data["ScalingMode"]
+            )
+        )
+    if "ScalingPolicies" in data:
+        import aws_sdk_lambda.types.capacity_provider_scaling_policies_list
+
+        out["scaling_policies"] = (
+            aws_sdk_lambda.types.capacity_provider_scaling_policies_list.deserialize_json(
+                data["ScalingPolicies"]
+            )
+        )
+    return out

aws_sdk_lambda/types/capacity_provider_scaling_mode.py

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

aws_sdk_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 aws_sdk_lambda.types.target_tracking_scaling_policy
+
+CapacityProviderScalingPoliciesList: TypeAlias = list[
+    "aws_sdk_lambda.types.target_tracking_scaling_policy.TargetTrackingScalingPolicy"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProviderScalingPoliciesList) -> list:
+    import aws_sdk_lambda.types.target_tracking_scaling_policy
+
+    out: list = []
+    for item in value:
+        out.append(
+            aws_sdk_lambda.types.target_tracking_scaling_policy.serialize_json(item)
+        )
+    return out
+
+
+def deserialize_json(data: list) -> CapacityProviderScalingPoliciesList:
+    import aws_sdk_lambda.types.target_tracking_scaling_policy
+
+    out: CapacityProviderScalingPoliciesList = []
+    for item in data:
+        out.append(
+            aws_sdk_lambda.types.target_tracking_scaling_policy.deserialize_json(item)
+        )
+    return out

aws_sdk_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 aws_sdk_lambda.types.security_group_id
+
+CapacityProviderSecurityGroupIds: TypeAlias = list[
+    "aws_sdk_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)

aws_sdk_lambda/types/capacity_provider_state.py

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

aws_sdk_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 aws_sdk_lambda.types.subnet_id
+
+CapacityProviderSubnetIds: TypeAlias = list["aws_sdk_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)

aws_sdk_lambda/types/capacity_provider_vpc_config.py

@@ -0,0 +1,63 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CapacityProviderVpcConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.capacity_provider_security_group_ids
+    import aws_sdk_lambda.types.capacity_provider_subnet_ids
+
+
+class CapacityProviderVpcConfig(TypedDict):
+    subnet_ids: (
+        "aws_sdk_lambda.types.capacity_provider_subnet_ids.CapacityProviderSubnetIds"
+    )
+    """<p>A list of subnet IDs where the capacity provider launches compute instances.</p>"""
+    security_group_ids: "aws_sdk_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 aws_sdk_lambda.types.capacity_provider_subnet_ids
+
+    out["SubnetIds"] = aws_sdk_lambda.types.capacity_provider_subnet_ids.serialize_json(
+        value["subnet_ids"]
+    )
+    import aws_sdk_lambda.types.capacity_provider_security_group_ids
+
+    out["SecurityGroupIds"] = (
+        aws_sdk_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 aws_sdk_lambda.types.capacity_provider_subnet_ids
+
+        out["subnet_ids"] = (
+            aws_sdk_lambda.types.capacity_provider_subnet_ids.deserialize_json(
+                data["SubnetIds"]
+            )
+        )
+    else:
+        raise DeserializationError("CapacityProviderVpcConfig.subnet_ids required")
+    if "SecurityGroupIds" in data:
+        import aws_sdk_lambda.types.capacity_provider_security_group_ids
+
+        out["security_group_ids"] = (
+            aws_sdk_lambda.types.capacity_provider_security_group_ids.deserialize_json(
+                data["SecurityGroupIds"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CapacityProviderVpcConfig.security_group_ids required"
+        )
+    return out

aws_sdk_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 aws_sdk_lambda.types.capacity_provider
+
+CapacityProvidersList: TypeAlias = list[
+    "aws_sdk_lambda.types.capacity_provider.CapacityProvider"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CapacityProvidersList) -> list:
+    import aws_sdk_lambda.types.capacity_provider
+
+    out: list = []
+    for item in value:
+        out.append(aws_sdk_lambda.types.capacity_provider.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> CapacityProvidersList:
+    import aws_sdk_lambda.types.capacity_provider
+
+    out: CapacityProvidersList = []
+    for item in data:
+        out.append(aws_sdk_lambda.types.capacity_provider.deserialize_json(item))
+    return out