capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/chained_invoke_options.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ChainedInvokeOptions``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.tenant_id
+
+
+class ChainedInvokeOptions(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    """<p>The name or ARN of the Lambda function to invoke.</p>"""
+    tenant_id: NotRequired["capo_lambda.types.tenant_id.TenantId"]
+    """<p>The tenant identifier for the chained invocation.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ChainedInvokeOptions) -> dict:
+    out: dict = {}
+    out["FunctionName"] = value["function_name"]
+    if "tenant_id" in value:
+        out["TenantId"] = value["tenant_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> ChainedInvokeOptions:
+    out: ChainedInvokeOptions = {}  # type: ignore[typeddict-item]
+    if "FunctionName" in data:
+        out["function_name"] = data["FunctionName"]
+    else:
+        raise DeserializationError("ChainedInvokeOptions.function_name required")
+    if "TenantId" in data:
+        out["tenant_id"] = data["TenantId"]
+    return out

capo_lambda/types/chained_invoke_started_details.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ChainedInvokeStartedDetails``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.durable_execution_arn
+    import capo_lambda.types.event_input
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.tenant_id
+    import capo_lambda.types.version_with_latest_published
+
+
+class ChainedInvokeStartedDetails(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    """<p>The name or ARN of the Lambda function being invoked.</p>"""
+    tenant_id: NotRequired["capo_lambda.types.tenant_id.TenantId"]
+    """<p>The tenant identifier for the chained invocation.</p>"""
+    input: NotRequired["capo_lambda.types.event_input.EventInput"]
+    """<p>The JSON input payload provided to the chained invocation.</p>"""
+    executed_version: NotRequired[
+        "capo_lambda.types.version_with_latest_published.VersionWithLatestPublished"
+    ]
+    """<p>The version of the function that was executed.</p>"""
+    durable_execution_arn: NotRequired[
+        "capo_lambda.types.durable_execution_arn.DurableExecutionArn"
+    ]
+    """<p>The Amazon Resource Name (ARN) that identifies the durable execution.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ChainedInvokeStartedDetails) -> dict:
+    out: dict = {}
+    out["FunctionName"] = value["function_name"]
+    if "tenant_id" in value:
+        out["TenantId"] = value["tenant_id"]
+    if "input" in value:
+        import capo_lambda.types.event_input
+
+        out["Input"] = capo_lambda.types.event_input.serialize_json(value["input"])
+    if "executed_version" in value:
+        out["ExecutedVersion"] = value["executed_version"]
+    if "durable_execution_arn" in value:
+        out["DurableExecutionArn"] = value["durable_execution_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> ChainedInvokeStartedDetails:
+    out: ChainedInvokeStartedDetails = {}  # type: ignore[typeddict-item]
+    if "FunctionName" in data:
+        out["function_name"] = data["FunctionName"]
+    else:
+        raise DeserializationError("ChainedInvokeStartedDetails.function_name required")
+    if "TenantId" in data:
+        out["tenant_id"] = data["TenantId"]
+    if "Input" in data:
+        import capo_lambda.types.event_input
+
+        out["input"] = capo_lambda.types.event_input.deserialize_json(data["Input"])
+    if "ExecutedVersion" in data:
+        out["executed_version"] = data["ExecutedVersion"]
+    if "DurableExecutionArn" in data:
+        out["durable_execution_arn"] = data["DurableExecutionArn"]
+    return out

capo_lambda/types/chained_invoke_stopped_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ChainedInvokeStoppedDetails``."""
+
+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 ChainedInvokeStoppedDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about why the chained invocation stopped.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ChainedInvokeStoppedDetails) -> 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) -> ChainedInvokeStoppedDetails:
+    out: ChainedInvokeStoppedDetails = {}  # 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("ChainedInvokeStoppedDetails.error required")
+    return out

capo_lambda/types/chained_invoke_succeeded_details.py

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

capo_lambda/types/chained_invoke_timed_out_details.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ChainedInvokeTimedOutDetails``."""
+
+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 ChainedInvokeTimedOutDetails(TypedDict, closed=True):
+    error: "capo_lambda.types.event_error.EventError"
+    """<p>Details about the chained invocation timeout.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ChainedInvokeTimedOutDetails) -> 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) -> ChainedInvokeTimedOutDetails:
+    out: ChainedInvokeTimedOutDetails = {}  # 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("ChainedInvokeTimedOutDetails.error required")
+    return out

capo_lambda/types/checkpoint_durable_execution_request.py

@@ -0,0 +1,58 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CheckpointDurableExecutionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.checkpoint_token
+    import capo_lambda.types.client_token
+    import capo_lambda.types.durable_execution_arn
+    import capo_lambda.types.operation_updates
+
+
+class CheckpointDurableExecutionRequest(TypedDict, closed=True):
+    durable_execution_arn: "capo_lambda.types.durable_execution_arn.DurableExecutionArn"
+    """<p>The Amazon Resource Name (ARN) of the durable execution.</p>"""
+    checkpoint_token: "capo_lambda.types.checkpoint_token.CheckpointToken"
+    """<p>A unique token that identifies the current checkpoint state. This token is provided by the Lambda runtime and must be used to ensure checkpoints are applied in the correct order. Each checkpoint operation consumes this token and returns a new one.</p>"""
+    updates: NotRequired["capo_lambda.types.operation_updates.OperationUpdates"]
+    """<p>An array of state updates to apply during this checkpoint. Each update represents a change to the execution state, such as completing a step, starting a callback, or scheduling a timer. Updates are applied atomically as part of the checkpoint operation.</p>"""
+    client_token: NotRequired["capo_lambda.types.client_token.ClientToken"]
+    """<p>An optional idempotency token to ensure that duplicate checkpoint requests are handled correctly. If provided, Lambda uses this token to detect and handle duplicate requests within a 15-minute window.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CheckpointDurableExecutionRequest) -> dict:
+    out: dict = {}
+    out["CheckpointToken"] = value["checkpoint_token"]
+    if "updates" in value:
+        import capo_lambda.types.operation_updates
+
+        out["Updates"] = capo_lambda.types.operation_updates.serialize_json(
+            value["updates"]
+        )
+    if "client_token" in value:
+        out["ClientToken"] = value["client_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> CheckpointDurableExecutionRequest:
+    out: CheckpointDurableExecutionRequest = {}  # type: ignore[typeddict-item]
+    if "CheckpointToken" in data:
+        out["checkpoint_token"] = data["CheckpointToken"]
+    else:
+        raise DeserializationError(
+            "CheckpointDurableExecutionRequest.checkpoint_token required"
+        )
+    if "Updates" in data:
+        import capo_lambda.types.operation_updates
+
+        out["updates"] = capo_lambda.types.operation_updates.deserialize_json(
+            data["Updates"]
+        )
+    if "ClientToken" in data:
+        out["client_token"] = data["ClientToken"]
+    return out

capo_lambda/types/checkpoint_durable_execution_response.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CheckpointDurableExecutionResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.checkpoint_token
+    import capo_lambda.types.checkpoint_updated_execution_state
+
+
+class CheckpointDurableExecutionResponse(TypedDict, closed=True):
+    checkpoint_token: NotRequired["capo_lambda.types.checkpoint_token.CheckpointToken"]
+    """<p>A new checkpoint token to use for the next checkpoint operation. This token replaces the one provided in the request and must be used for subsequent checkpoints to maintain proper ordering.</p>"""
+    new_execution_state: "capo_lambda.types.checkpoint_updated_execution_state.CheckpointUpdatedExecutionState"
+    """<p>Updated execution state information that includes any changes that occurred since the last checkpoint, such as completed callbacks or expired timers. This allows the SDK to update its internal state during replay.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CheckpointDurableExecutionResponse) -> dict:
+    out: dict = {}
+    if "checkpoint_token" in value:
+        out["CheckpointToken"] = value["checkpoint_token"]
+    import capo_lambda.types.checkpoint_updated_execution_state
+
+    out["NewExecutionState"] = (
+        capo_lambda.types.checkpoint_updated_execution_state.serialize_json(
+            value["new_execution_state"]
+        )
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> CheckpointDurableExecutionResponse:
+    out: CheckpointDurableExecutionResponse = {}  # type: ignore[typeddict-item]
+    if "CheckpointToken" in data:
+        out["checkpoint_token"] = data["CheckpointToken"]
+    if "NewExecutionState" in data:
+        import capo_lambda.types.checkpoint_updated_execution_state
+
+        out["new_execution_state"] = (
+            capo_lambda.types.checkpoint_updated_execution_state.deserialize_json(
+                data["NewExecutionState"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "CheckpointDurableExecutionResponse.new_execution_state required"
+        )
+    return out

capo_lambda/types/checkpoint_token.py

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

capo_lambda/types/checkpoint_updated_execution_state.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CheckpointUpdatedExecutionState``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.operations
+    import capo_lambda.types.string
+
+
+class CheckpointUpdatedExecutionState(TypedDict, closed=True):
+    operations: NotRequired["capo_lambda.types.operations.Operations"]
+    """<p>A list of operations that have been updated since the last checkpoint.</p>"""
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Indicates that more results are available. Use this value in a subsequent call to retrieve the next page of results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CheckpointUpdatedExecutionState) -> dict:
+    out: dict = {}
+    if "operations" in value:
+        import capo_lambda.types.operations
+
+        out["Operations"] = capo_lambda.types.operations.serialize_json(
+            value["operations"]
+        )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> CheckpointUpdatedExecutionState:
+    out: CheckpointUpdatedExecutionState = {}  # type: ignore[typeddict-item]
+    if "Operations" in data:
+        import capo_lambda.types.operations
+
+        out["operations"] = capo_lambda.types.operations.deserialize_json(
+            data["Operations"]
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/client_token.py

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

capo_lambda/types/code_signing_config.py

@@ -0,0 +1,94 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CodeSigningConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.allowed_publishers
+    import capo_lambda.types.code_signing_config_arn
+    import capo_lambda.types.code_signing_config_id
+    import capo_lambda.types.code_signing_policies
+    import capo_lambda.types.description
+    import capo_lambda.types.timestamp
+
+
+class CodeSigningConfig(TypedDict, closed=True):
+    code_signing_config_id: (
+        "capo_lambda.types.code_signing_config_id.CodeSigningConfigId"
+    )
+    """<p>Unique identifer for the Code signing configuration.</p>"""
+    code_signing_config_arn: (
+        "capo_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the Code signing configuration.</p>"""
+    description: NotRequired["capo_lambda.types.description.Description"]
+    """<p>Code signing configuration description.</p>"""
+    allowed_publishers: "capo_lambda.types.allowed_publishers.AllowedPublishers"
+    """<p>List of allowed publishers.</p>"""
+    code_signing_policies: "capo_lambda.types.code_signing_policies.CodeSigningPolicies"
+    """<p>The code signing policy controls the validation failure action for signature mismatch or expiry.</p>"""
+    last_modified: "capo_lambda.types.timestamp.Timestamp"
+    """<p>The date and time that the Code signing configuration was last modified, in ISO-8601 format (YYYY-MM-DDThh:mm:ss.sTZD). </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CodeSigningConfig) -> dict:
+    out: dict = {}
+    out["CodeSigningConfigId"] = value["code_signing_config_id"]
+    out["CodeSigningConfigArn"] = value["code_signing_config_arn"]
+    if "description" in value:
+        out["Description"] = value["description"]
+    import capo_lambda.types.allowed_publishers
+
+    out["AllowedPublishers"] = capo_lambda.types.allowed_publishers.serialize_json(
+        value["allowed_publishers"]
+    )
+    import capo_lambda.types.code_signing_policies
+
+    out["CodeSigningPolicies"] = capo_lambda.types.code_signing_policies.serialize_json(
+        value["code_signing_policies"]
+    )
+    out["LastModified"] = value["last_modified"]
+    return out
+
+
+def deserialize_json(data: dict) -> CodeSigningConfig:
+    out: CodeSigningConfig = {}  # type: ignore[typeddict-item]
+    if "CodeSigningConfigId" in data:
+        out["code_signing_config_id"] = data["CodeSigningConfigId"]
+    else:
+        raise DeserializationError("CodeSigningConfig.code_signing_config_id required")
+    if "CodeSigningConfigArn" in data:
+        out["code_signing_config_arn"] = data["CodeSigningConfigArn"]
+    else:
+        raise DeserializationError("CodeSigningConfig.code_signing_config_arn required")
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "AllowedPublishers" in data:
+        import capo_lambda.types.allowed_publishers
+
+        out["allowed_publishers"] = (
+            capo_lambda.types.allowed_publishers.deserialize_json(
+                data["AllowedPublishers"]
+            )
+        )
+    else:
+        raise DeserializationError("CodeSigningConfig.allowed_publishers required")
+    if "CodeSigningPolicies" in data:
+        import capo_lambda.types.code_signing_policies
+
+        out["code_signing_policies"] = (
+            capo_lambda.types.code_signing_policies.deserialize_json(
+                data["CodeSigningPolicies"]
+            )
+        )
+    else:
+        raise DeserializationError("CodeSigningConfig.code_signing_policies required")
+    if "LastModified" in data:
+        out["last_modified"] = data["LastModified"]
+    else:
+        raise DeserializationError("CodeSigningConfig.last_modified required")
+    return out

capo_lambda/types/code_signing_config_arn.py

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

capo_lambda/types/code_signing_config_id.py

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

capo_lambda/types/code_signing_config_list.py

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

capo_lambda/types/code_signing_policies.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#CodeSigningPolicies``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.code_signing_policy
+
+
+class CodeSigningPolicies(TypedDict, closed=True):
+    untrusted_artifact_on_deployment: NotRequired[
+        "capo_lambda.types.code_signing_policy.CodeSigningPolicy"
+    ]
+    """<p>Code signing configuration policy for deployment validation failure. If you set the policy to <code>Enforce</code>, Lambda blocks the deployment request if signature validation checks fail. If you set the policy to <code>Warn</code>, Lambda allows the deployment and issues a new Amazon CloudWatch metric (<code>SignatureValidationErrors</code>) and also stores the warning in the CloudTrail log.</p> <p>Default value: <code>Warn</code> </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: CodeSigningPolicies) -> dict:
+    out: dict = {}
+    if "untrusted_artifact_on_deployment" in value:
+        import capo_lambda.types.code_signing_policy
+
+        out["UntrustedArtifactOnDeployment"] = (
+            capo_lambda.types.code_signing_policy.serialize_json(
+                value["untrusted_artifact_on_deployment"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> CodeSigningPolicies:
+    out: CodeSigningPolicies = {}  # type: ignore[typeddict-item]
+    if "UntrustedArtifactOnDeployment" in data:
+        import capo_lambda.types.code_signing_policy
+
+        out["untrusted_artifact_on_deployment"] = (
+            capo_lambda.types.code_signing_policy.deserialize_json(
+                data["UntrustedArtifactOnDeployment"]
+            )
+        )
+    return out

capo_lambda/types/code_signing_policy.py

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

capo_lambda/types/collection_name.py

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

capo_lambda/types/compatible_architectures.py

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

capo_lambda/types/compatible_runtimes.py

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