capo-lambda-web 0.2.0__py3-none-any.whl

capo_lambda_web/types/logging_config.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#LoggingConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.application_log_level
+    import capo_lambda_web.types.system_log_level
+
+
+class LoggingConfig(TypedDict, closed=True):
+    log_group: NotRequired["str"]
+    """<p>The name of the Amazon CloudWatch Logs log group the web function sends logs to. If you don't specify a value, the default is <code>/aws/lambda/web/{functionName}</code>, and this default is returned in the response.</p>"""
+    application_log_level: NotRequired[
+        "capo_lambda_web.types.application_log_level.ApplicationLogLevel"
+    ]
+    """<p>The log level for application logs emitted by the web function. If you don't specify a value, the default is <code>INFO</code>, and this default is returned in the response.</p>"""
+    system_log_level: NotRequired[
+        "capo_lambda_web.types.system_log_level.SystemLogLevel"
+    ]
+    """<p>The log level for system logs emitted by the Lambda runtime. If you don't specify a value, the default is <code>INFO</code>, and this default is returned in the response.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: LoggingConfig) -> dict:
+    out: dict = {}
+    if "log_group" in value:
+        out["logGroup"] = value["log_group"]
+    if "application_log_level" in value:
+        import capo_lambda_web.types.application_log_level
+
+        out["applicationLogLevel"] = (
+            capo_lambda_web.types.application_log_level.serialize_json(
+                value["application_log_level"]
+            )
+        )
+    if "system_log_level" in value:
+        import capo_lambda_web.types.system_log_level
+
+        out["systemLogLevel"] = capo_lambda_web.types.system_log_level.serialize_json(
+            value["system_log_level"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> LoggingConfig:
+    out: LoggingConfig = {}  # type: ignore[typeddict-item]
+    if data.get("logGroup") is not None:
+        out["log_group"] = data["logGroup"]
+    if data.get("applicationLogLevel") is not None:
+        import capo_lambda_web.types.application_log_level
+
+        out["application_log_level"] = (
+            capo_lambda_web.types.application_log_level.deserialize_json(
+                data["applicationLogLevel"]
+            )
+        )
+    if data.get("systemLogLevel") is not None:
+        import capo_lambda_web.types.system_log_level
+
+        out["system_log_level"] = (
+            capo_lambda_web.types.system_log_level.deserialize_json(
+                data["systemLogLevel"]
+            )
+        )
+    return out

capo_lambda_web/types/max_results.py

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

capo_lambda_web/types/next_token.py

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

capo_lambda_web/types/policy_revision_id.py

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

capo_lambda_web/types/put_resource_policy_request.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#PutResourcePolicyRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.policy_revision_id
+    import capo_lambda_web.types.resource_arn
+    import capo_lambda_web.types.resource_policy
+
+
+class PutResourcePolicyRequest(TypedDict, closed=True):
+    resource_arn: "capo_lambda_web.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the web function.</p>"""
+    policy: "capo_lambda_web.types.resource_policy.ResourcePolicy"
+    """<p>The JSON-formatted resource-based policy to attach to the web function.</p>"""
+    revision_id: NotRequired[
+        "capo_lambda_web.types.policy_revision_id.PolicyRevisionId"
+    ]
+    """<p>The revision ID of the existing policy. Use this to prevent conflicts when updating a policy concurrently. If you don't specify a value, the update proceeds without checking the current revision.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutResourcePolicyRequest) -> dict:
+    out: dict = {}
+    out["Policy"] = value["policy"]
+    if "revision_id" in value:
+        out["RevisionId"] = value["revision_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutResourcePolicyRequest:
+    out: PutResourcePolicyRequest = {}  # type: ignore[typeddict-item]
+    if data.get("Policy") is not None:
+        out["policy"] = data["Policy"]
+    else:
+        raise DeserializationError("PutResourcePolicyRequest.policy required")
+    if data.get("RevisionId") is not None:
+        out["revision_id"] = data["RevisionId"]
+    return out

capo_lambda_web/types/put_resource_policy_response.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#PutResourcePolicyResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.policy_revision_id
+    import capo_lambda_web.types.resource_policy
+
+
+class PutResourcePolicyResponse(TypedDict, closed=True):
+    policy: "capo_lambda_web.types.resource_policy.ResourcePolicy"
+    """<p>The JSON-formatted resource-based policy attached to the web function.</p>"""
+    revision_id: "capo_lambda_web.types.policy_revision_id.PolicyRevisionId"
+    """<p>The revision ID of the policy. Use this value in subsequent <code>PutResourcePolicy</code> or <code>DeleteResourcePolicy</code> requests to prevent conflicts.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PutResourcePolicyResponse) -> dict:
+    out: dict = {}
+    out["Policy"] = value["policy"]
+    out["RevisionId"] = value["revision_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> PutResourcePolicyResponse:
+    out: PutResourcePolicyResponse = {}  # type: ignore[typeddict-item]
+    if data.get("Policy") is not None:
+        out["policy"] = data["Policy"]
+    else:
+        raise DeserializationError("PutResourcePolicyResponse.policy required")
+    if data.get("RevisionId") is not None:
+        out["revision_id"] = data["RevisionId"]
+    else:
+        raise DeserializationError("PutResourcePolicyResponse.revision_id required")
+    return out

capo_lambda_web/types/region.py

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

capo_lambda_web/types/region_list.py

@@ -0,0 +1,17 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RegionList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.region
+
+RegionList: TypeAlias = list["capo_lambda_web.types.region.Region"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegionList) -> list:
+    return list(value)
+
+
+def deserialize_json(data: list) -> RegionList:
+    return [item for item in data if item is not None]

capo_lambda_web/types/regional_endpoint.py

@@ -0,0 +1,140 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RegionalEndpoint``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.auth_type
+    import capo_lambda_web.types.domain_name
+    import capo_lambda_web.types.endpoint_state
+    import capo_lambda_web.types.endpoint_update_status
+    import capo_lambda_web.types.revision_weight_list
+    import capo_lambda_web.types.scaling_config
+    import capo_lambda_web.types.throttle_config
+
+
+class RegionalEndpoint(TypedDict, closed=True):
+    domain_name: NotRequired["capo_lambda_web.types.domain_name.DomainName"]
+    """<p>The domain name of the regional endpoint.</p>"""
+    auth_type: "capo_lambda_web.types.auth_type.AuthType"
+    """<p>The authorization type for the regional endpoint.</p>"""
+    revision_weights: "capo_lambda_web.types.revision_weight_list.RevisionWeightList"
+    """<p>The revision weights for the regional endpoint.</p>"""
+    scaling_config: NotRequired["capo_lambda_web.types.scaling_config.ScalingConfig"]
+    """<p>The scaling configuration for the regional endpoint. This field is absent if the endpoint has no scaling configuration.</p>"""
+    throttle_config: NotRequired["capo_lambda_web.types.throttle_config.ThrottleConfig"]
+    """<p>The throttling configuration for the regional endpoint. This field is absent if the endpoint has no throttling configuration.</p>"""
+    state: "capo_lambda_web.types.endpoint_state.EndpointState"
+    """<p>The current state of the regional endpoint.</p>"""
+    state_reason: "str"
+    """<p>The reason for the current state of the regional endpoint.</p>"""
+    update_status: NotRequired[
+        "capo_lambda_web.types.endpoint_update_status.EndpointUpdateStatus"
+    ]
+    """<p>The status of the most recent update to the regional endpoint.</p>"""
+    update_status_reason: NotRequired["str"]
+    """<p>The reason for the current update status of the regional endpoint.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RegionalEndpoint) -> dict:
+    out: dict = {}
+    if "domain_name" in value:
+        out["domainName"] = value["domain_name"]
+    import capo_lambda_web.types.auth_type
+
+    out["authType"] = capo_lambda_web.types.auth_type.serialize_json(value["auth_type"])
+    import capo_lambda_web.types.revision_weight_list
+
+    out["revisionWeights"] = capo_lambda_web.types.revision_weight_list.serialize_json(
+        value["revision_weights"]
+    )
+    if "scaling_config" in value:
+        import capo_lambda_web.types.scaling_config
+
+        out["scalingConfig"] = capo_lambda_web.types.scaling_config.serialize_json(
+            value["scaling_config"]
+        )
+    if "throttle_config" in value:
+        import capo_lambda_web.types.throttle_config
+
+        out["throttleConfig"] = capo_lambda_web.types.throttle_config.serialize_json(
+            value["throttle_config"]
+        )
+    import capo_lambda_web.types.endpoint_state
+
+    out["state"] = capo_lambda_web.types.endpoint_state.serialize_json(value["state"])
+    out["stateReason"] = value["state_reason"]
+    if "update_status" in value:
+        import capo_lambda_web.types.endpoint_update_status
+
+        out["updateStatus"] = (
+            capo_lambda_web.types.endpoint_update_status.serialize_json(
+                value["update_status"]
+            )
+        )
+    if "update_status_reason" in value:
+        out["updateStatusReason"] = value["update_status_reason"]
+    return out
+
+
+def deserialize_json(data: dict) -> RegionalEndpoint:
+    out: RegionalEndpoint = {}  # type: ignore[typeddict-item]
+    if data.get("domainName") is not None:
+        out["domain_name"] = data["domainName"]
+    if data.get("authType") is not None:
+        import capo_lambda_web.types.auth_type
+
+        out["auth_type"] = capo_lambda_web.types.auth_type.deserialize_json(
+            data["authType"]
+        )
+    else:
+        raise DeserializationError("RegionalEndpoint.auth_type required")
+    if data.get("revisionWeights") is not None:
+        import capo_lambda_web.types.revision_weight_list
+
+        out["revision_weights"] = (
+            capo_lambda_web.types.revision_weight_list.deserialize_json(
+                data["revisionWeights"]
+            )
+        )
+    else:
+        raise DeserializationError("RegionalEndpoint.revision_weights required")
+    if data.get("scalingConfig") is not None:
+        import capo_lambda_web.types.scaling_config
+
+        out["scaling_config"] = capo_lambda_web.types.scaling_config.deserialize_json(
+            data["scalingConfig"]
+        )
+    if data.get("throttleConfig") is not None:
+        import capo_lambda_web.types.throttle_config
+
+        out["throttle_config"] = capo_lambda_web.types.throttle_config.deserialize_json(
+            data["throttleConfig"]
+        )
+    if data.get("state") is not None:
+        import capo_lambda_web.types.endpoint_state
+
+        out["state"] = capo_lambda_web.types.endpoint_state.deserialize_json(
+            data["state"]
+        )
+    else:
+        raise DeserializationError("RegionalEndpoint.state required")
+    if data.get("stateReason") is not None:
+        out["state_reason"] = data["stateReason"]
+    else:
+        raise DeserializationError("RegionalEndpoint.state_reason required")
+    if data.get("updateStatus") is not None:
+        import capo_lambda_web.types.endpoint_update_status
+
+        out["update_status"] = (
+            capo_lambda_web.types.endpoint_update_status.deserialize_json(
+                data["updateStatus"]
+            )
+        )
+    if data.get("updateStatusReason") is not None:
+        out["update_status_reason"] = data["updateStatusReason"]
+    return out

capo_lambda_web/types/regional_endpoints.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RegionalEndpoints``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.region
+    import capo_lambda_web.types.regional_endpoint
+
+RegionalEndpoints: TypeAlias = dict[
+    "capo_lambda_web.types.region.Region",
+    "capo_lambda_web.types.regional_endpoint.RegionalEndpoint",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: RegionalEndpoints) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        import capo_lambda_web.types.regional_endpoint
+
+        out[key] = capo_lambda_web.types.regional_endpoint.serialize_json(value)
+    return out
+
+
+def deserialize_json(data: dict) -> RegionalEndpoints:
+    out: RegionalEndpoints = {}
+    for key, value in data.items():
+        if value is None:
+            continue
+        import capo_lambda_web.types.regional_endpoint
+
+        out[key] = capo_lambda_web.types.regional_endpoint.deserialize_json(value)
+    return out

capo_lambda_web/types/resource_arn.py

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

capo_lambda_web/types/resource_policy.py

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

capo_lambda_web/types/revision_arn.py

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

capo_lambda_web/types/revision_config.py

@@ -0,0 +1,69 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RevisionConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.build_config
+    import capo_lambda_web.types.description
+    import capo_lambda_web.types.kms_key_arn
+    import capo_lambda_web.types.service_config
+
+
+class RevisionConfig(TypedDict, closed=True):
+    description: NotRequired["capo_lambda_web.types.description.Description"]
+    """<p>A description of the revision.</p>"""
+    kms_key_arn: NotRequired["capo_lambda_web.types.kms_key_arn.KmsKeyArn"]
+    """<p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) key used to encrypt the revision's code and environment variables.</p>"""
+    build_config: "capo_lambda_web.types.build_config.BuildConfig"
+    """<p>The build configuration for the revision.</p>"""
+    service_config: "capo_lambda_web.types.service_config.ServiceConfig"
+    """<p>The service configuration for the revision.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RevisionConfig) -> dict:
+    out: dict = {}
+    if "description" in value:
+        out["description"] = value["description"]
+    if "kms_key_arn" in value:
+        out["kmsKeyArn"] = value["kms_key_arn"]
+    import capo_lambda_web.types.build_config
+
+    out["buildConfig"] = capo_lambda_web.types.build_config.serialize_json(
+        value["build_config"]
+    )
+    import capo_lambda_web.types.service_config
+
+    out["serviceConfig"] = capo_lambda_web.types.service_config.serialize_json(
+        value["service_config"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> RevisionConfig:
+    out: RevisionConfig = {}  # type: ignore[typeddict-item]
+    if data.get("description") is not None:
+        out["description"] = data["description"]
+    if data.get("kmsKeyArn") is not None:
+        out["kms_key_arn"] = data["kmsKeyArn"]
+    if data.get("buildConfig") is not None:
+        import capo_lambda_web.types.build_config
+
+        out["build_config"] = capo_lambda_web.types.build_config.deserialize_json(
+            data["buildConfig"]
+        )
+    else:
+        raise DeserializationError("RevisionConfig.build_config required")
+    if data.get("serviceConfig") is not None:
+        import capo_lambda_web.types.service_config
+
+        out["service_config"] = capo_lambda_web.types.service_config.deserialize_json(
+            data["serviceConfig"]
+        )
+    else:
+        raise DeserializationError("RevisionConfig.service_config required")
+    return out

capo_lambda_web/types/revision_error.py

@@ -0,0 +1,40 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RevisionError``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+
+class RevisionError(TypedDict, closed=True):
+    attribute: "str"
+    """<p>The name of the revision attribute that the error applies to. Must be between 1 and 64 characters.</p>"""
+    error_code: "str"
+    """<p>A short, machine-readable code that identifies the error. Must be between 1 and 64 characters.</p>"""
+    error_message: "str"
+    """<p>A human-readable message describing the error. Must be between 1 and 2048 characters.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RevisionError) -> dict:
+    out: dict = {}
+    out["attribute"] = value["attribute"]
+    out["errorCode"] = value["error_code"]
+    out["errorMessage"] = value["error_message"]
+    return out
+
+
+def deserialize_json(data: dict) -> RevisionError:
+    out: RevisionError = {}  # type: ignore[typeddict-item]
+    if data.get("attribute") is not None:
+        out["attribute"] = data["attribute"]
+    else:
+        raise DeserializationError("RevisionError.attribute required")
+    if data.get("errorCode") is not None:
+        out["error_code"] = data["errorCode"]
+    else:
+        raise DeserializationError("RevisionError.error_code required")
+    if data.get("errorMessage") is not None:
+        out["error_message"] = data["errorMessage"]
+    else:
+        raise DeserializationError("RevisionError.error_message required")
+    return out

capo_lambda_web/types/revision_errors.py

@@ -0,0 +1,29 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RevisionErrors``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.revision_error
+
+RevisionErrors: TypeAlias = list["capo_lambda_web.types.revision_error.RevisionError"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RevisionErrors) -> list:
+    import capo_lambda_web.types.revision_error
+
+    out: list = []
+    for item in value:
+        out.append(capo_lambda_web.types.revision_error.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> RevisionErrors:
+    import capo_lambda_web.types.revision_error
+
+    out: RevisionErrors = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_lambda_web.types.revision_error.deserialize_json(item))
+    return out

capo_lambda_web/types/revision_id.py

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

capo_lambda_web/types/revision_state.py

@@ -0,0 +1,19 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RevisionState``."""
+
+from typing import Literal, TypeAlias, cast
+
+"""<p>The state of a web function revision. Possible values: <code>Pending</code> (revision is being built), <code>Active</code> (revision is ready to serve traffic), <code>Failed</code> (revision build failed).</p>"""
+RevisionState: TypeAlias = Literal[
+    "Pending",
+    "Active",
+    "Failed",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RevisionState) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> RevisionState:
+    return cast(RevisionState, data)

capo_lambda_web/types/revision_weight.py

@@ -0,0 +1,38 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RevisionWeight``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.revision_id
+
+
+class RevisionWeight(TypedDict, closed=True):
+    revision_id: "capo_lambda_web.types.revision_id.RevisionId"
+    """<p>The identifier of the revision.</p>"""
+    weight: "int"
+    """<p>The percentage of traffic to route to this revision. Minimum value of 1, maximum value of 100.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RevisionWeight) -> dict:
+    out: dict = {}
+    out["revisionId"] = value["revision_id"]
+    out["weight"] = value["weight"]
+    return out
+
+
+def deserialize_json(data: dict) -> RevisionWeight:
+    out: RevisionWeight = {}  # type: ignore[typeddict-item]
+    if data.get("revisionId") is not None:
+        out["revision_id"] = data["revisionId"]
+    else:
+        raise DeserializationError("RevisionWeight.revision_id required")
+    if data.get("weight") is not None:
+        out["weight"] = data["weight"]
+    else:
+        raise DeserializationError("RevisionWeight.weight required")
+    return out

capo_lambda_web/types/revision_weight_list.py

@@ -0,0 +1,31 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RevisionWeightList``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.revision_weight
+
+RevisionWeightList: TypeAlias = list[
+    "capo_lambda_web.types.revision_weight.RevisionWeight"
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RevisionWeightList) -> list:
+    import capo_lambda_web.types.revision_weight
+
+    out: list = []
+    for item in value:
+        out.append(capo_lambda_web.types.revision_weight.serialize_json(item))
+    return out
+
+
+def deserialize_json(data: list) -> RevisionWeightList:
+    import capo_lambda_web.types.revision_weight
+
+    out: RevisionWeightList = []
+    for item in data:
+        if item is None:
+            continue
+        out.append(capo_lambda_web.types.revision_weight.deserialize_json(item))
+    return out

capo_lambda_web/types/role_arn.py

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

capo_lambda_web/types/runtime_config.py

@@ -0,0 +1,26 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#RuntimeConfig``."""
+
+from typing_extensions import TypedDict
+
+from capo_lambda_web.errors import DeserializationError
+
+
+class RuntimeConfig(TypedDict, closed=True):
+    runtime: "str"
+    """<p>The runtime identifier for the web function (for example, a Node.js runtime identifier).</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: RuntimeConfig) -> dict:
+    out: dict = {}
+    out["runtime"] = value["runtime"]
+    return out
+
+
+def deserialize_json(data: dict) -> RuntimeConfig:
+    out: RuntimeConfig = {}  # type: ignore[typeddict-item]
+    if data.get("runtime") is not None:
+        out["runtime"] = data["runtime"]
+    else:
+        raise DeserializationError("RuntimeConfig.runtime required")
+    return out