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

aws_sdk_lambda/types/kafka_schema_registry_config.py

@@ -0,0 +1,93 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaRegistryConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.kafka_schema_registry_access_config_list
+    import aws_sdk_lambda.types.kafka_schema_validation_config_list
+    import aws_sdk_lambda.types.schema_registry_event_record_format
+    import aws_sdk_lambda.types.schema_registry_uri
+
+
+class KafkaSchemaRegistryConfig(TypedDict):
+    schema_registry_uri: NotRequired[
+        "aws_sdk_lambda.types.schema_registry_uri.SchemaRegistryUri"
+    ]
+    """<p>The URI for your schema registry. The correct URI format depends on the type of schema registry you're using.</p> <ul> <li> <p>For Glue schema registries, use the ARN of the registry.</p> </li> <li> <p>For Confluent schema registries, use the URL of the registry.</p> </li> </ul>"""
+    event_record_format: NotRequired[
+        "aws_sdk_lambda.types.schema_registry_event_record_format.SchemaRegistryEventRecordFormat"
+    ]
+    """<p>The record format that Lambda delivers to your function after schema validation.</p> <ul> <li> <p>Choose <code>JSON</code> to have Lambda deliver the record to your function as a standard JSON object.</p> </li> <li> <p>Choose <code>SOURCE</code> to have Lambda deliver the record to your function in its original source format. Lambda removes all schema metadata, such as the schema ID, before sending the record to your function.</p> </li> </ul>"""
+    access_configs: NotRequired[
+        "aws_sdk_lambda.types.kafka_schema_registry_access_config_list.KafkaSchemaRegistryAccessConfigList"
+    ]
+    """<p>An array of access configuration objects that tell Lambda how to authenticate with your schema registry.</p>"""
+    schema_validation_configs: NotRequired[
+        "aws_sdk_lambda.types.kafka_schema_validation_config_list.KafkaSchemaValidationConfigList"
+    ]
+    """<p>An array of schema validation configuration objects, which tell Lambda the message attributes you want to validate and filter using your schema registry.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaRegistryConfig) -> dict:
+    out: dict = {}
+    if "schema_registry_uri" in value:
+        out["SchemaRegistryURI"] = value["schema_registry_uri"]
+    if "event_record_format" in value:
+        import aws_sdk_lambda.types.schema_registry_event_record_format
+
+        out["EventRecordFormat"] = (
+            aws_sdk_lambda.types.schema_registry_event_record_format.serialize_json(
+                value["event_record_format"]
+            )
+        )
+    if "access_configs" in value:
+        import aws_sdk_lambda.types.kafka_schema_registry_access_config_list
+
+        out["AccessConfigs"] = (
+            aws_sdk_lambda.types.kafka_schema_registry_access_config_list.serialize_json(
+                value["access_configs"]
+            )
+        )
+    if "schema_validation_configs" in value:
+        import aws_sdk_lambda.types.kafka_schema_validation_config_list
+
+        out["SchemaValidationConfigs"] = (
+            aws_sdk_lambda.types.kafka_schema_validation_config_list.serialize_json(
+                value["schema_validation_configs"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> KafkaSchemaRegistryConfig:
+    out: KafkaSchemaRegistryConfig = {}  # type: ignore[typeddict-item]
+    if "SchemaRegistryURI" in data:
+        out["schema_registry_uri"] = data["SchemaRegistryURI"]
+    if "EventRecordFormat" in data:
+        import aws_sdk_lambda.types.schema_registry_event_record_format
+
+        out["event_record_format"] = (
+            aws_sdk_lambda.types.schema_registry_event_record_format.deserialize_json(
+                data["EventRecordFormat"]
+            )
+        )
+    if "AccessConfigs" in data:
+        import aws_sdk_lambda.types.kafka_schema_registry_access_config_list
+
+        out["access_configs"] = (
+            aws_sdk_lambda.types.kafka_schema_registry_access_config_list.deserialize_json(
+                data["AccessConfigs"]
+            )
+        )
+    if "SchemaValidationConfigs" in data:
+        import aws_sdk_lambda.types.kafka_schema_validation_config_list
+
+        out["schema_validation_configs"] = (
+            aws_sdk_lambda.types.kafka_schema_validation_config_list.deserialize_json(
+                data["SchemaValidationConfigs"]
+            )
+        )
+    return out

aws_sdk_lambda/types/kafka_schema_validation_attribute.py

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

aws_sdk_lambda/types/kafka_schema_validation_config.py

@@ -0,0 +1,42 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#KafkaSchemaValidationConfig``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.kafka_schema_validation_attribute
+
+
+class KafkaSchemaValidationConfig(TypedDict):
+    attribute: NotRequired[
+        "aws_sdk_lambda.types.kafka_schema_validation_attribute.KafkaSchemaValidationAttribute"
+    ]
+    """<p> The attributes you want your schema registry to validate and filter for. If you selected <code>JSON</code> as the <code>EventRecordFormat</code>, Lambda also deserializes the selected message attributes. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: KafkaSchemaValidationConfig) -> dict:
+    out: dict = {}
+    if "attribute" in value:
+        import aws_sdk_lambda.types.kafka_schema_validation_attribute
+
+        out["Attribute"] = (
+            aws_sdk_lambda.types.kafka_schema_validation_attribute.serialize_json(
+                value["attribute"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> KafkaSchemaValidationConfig:
+    out: KafkaSchemaValidationConfig = {}  # type: ignore[typeddict-item]
+    if "Attribute" in data:
+        import aws_sdk_lambda.types.kafka_schema_validation_attribute
+
+        out["attribute"] = (
+            aws_sdk_lambda.types.kafka_schema_validation_attribute.deserialize_json(
+                data["Attribute"]
+            )
+        )
+    return out

aws_sdk_lambda/types/kafka_schema_validation_config_list.py

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

aws_sdk_lambda/types/kms_key_arn.py

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

aws_sdk_lambda/types/kms_key_arn_non_empty.py

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

aws_sdk_lambda/types/lambda_managed_instances_capacity_provider_config.py

@@ -0,0 +1,61 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#LambdaManagedInstancesCapacityProviderConfig``."""
+
+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.execution_environment_memory_gi_b_per_v_cpu
+    import aws_sdk_lambda.types.per_execution_environment_max_concurrency
+
+
+class LambdaManagedInstancesCapacityProviderConfig(TypedDict):
+    capacity_provider_arn: (
+        "aws_sdk_lambda.types.capacity_provider_arn.CapacityProviderArn"
+    )
+    """<p>The Amazon Resource Name (ARN) of the capacity provider.</p>"""
+    per_execution_environment_max_concurrency: NotRequired[
+        "aws_sdk_lambda.types.per_execution_environment_max_concurrency.PerExecutionEnvironmentMaxConcurrency"
+    ]
+    """<p>The maximum number of concurrent execution environments that can run on each compute instance.</p>"""
+    execution_environment_memory_gi_b_per_v_cpu: NotRequired[
+        "aws_sdk_lambda.types.execution_environment_memory_gi_b_per_v_cpu.ExecutionEnvironmentMemoryGiBPerVCpu"
+    ]
+    """<p>The amount of memory in GiB allocated per vCPU for execution environments.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: LambdaManagedInstancesCapacityProviderConfig) -> dict:
+    out: dict = {}
+    out["CapacityProviderArn"] = value["capacity_provider_arn"]
+    if "per_execution_environment_max_concurrency" in value:
+        out["PerExecutionEnvironmentMaxConcurrency"] = value[
+            "per_execution_environment_max_concurrency"
+        ]
+    if "execution_environment_memory_gi_b_per_v_cpu" in value:
+        out["ExecutionEnvironmentMemoryGiBPerVCpu"] = value[
+            "execution_environment_memory_gi_b_per_v_cpu"
+        ]
+    return out
+
+
+def deserialize_json(data: dict) -> LambdaManagedInstancesCapacityProviderConfig:
+    out: LambdaManagedInstancesCapacityProviderConfig = {}  # type: ignore[typeddict-item]
+    if "CapacityProviderArn" in data:
+        out["capacity_provider_arn"] = data["CapacityProviderArn"]
+    else:
+        raise DeserializationError(
+            "LambdaManagedInstancesCapacityProviderConfig.capacity_provider_arn required"
+        )
+    if "PerExecutionEnvironmentMaxConcurrency" in data:
+        out["per_execution_environment_max_concurrency"] = data[
+            "PerExecutionEnvironmentMaxConcurrency"
+        ]
+    if "ExecutionEnvironmentMemoryGiBPerVCpu" in data:
+        out["execution_environment_memory_gi_b_per_v_cpu"] = data[
+            "ExecutionEnvironmentMemoryGiBPerVCpu"
+        ]
+    return out

aws_sdk_lambda/types/last_update_status.py

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

aws_sdk_lambda/types/last_update_status_reason.py

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

aws_sdk_lambda/types/last_update_status_reason_code.py

@@ -0,0 +1,95 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#LastUpdateStatusReasonCode``."""
+
+from typing import Literal, TypeAlias, cast
+
+from aws_sdk_lambda.errors import DeserializationError
+
+LastUpdateStatusReasonCode: TypeAlias = Literal[
+    "EniLimitExceeded",
+    "InsufficientRolePermissions",
+    "InvalidConfiguration",
+    "InternalError",
+    "SubnetOutOfIPAddresses",
+    "InvalidSubnet",
+    "InvalidSecurityGroup",
+    "ImageDeleted",
+    "ImageAccessDenied",
+    "InvalidImage",
+    "KMSKeyAccessDenied",
+    "KMSKeyNotFound",
+    "InvalidStateKMSKey",
+    "DisabledKMSKey",
+    "EFSIOError",
+    "EFSMountConnectivityError",
+    "EFSMountFailure",
+    "EFSMountTimeout",
+    "InvalidRuntime",
+    "InvalidZipFileException",
+    "FunctionError",
+    "VcpuLimitExceeded",
+    "CapacityProviderScalingLimitExceeded",
+    "InsufficientCapacity",
+    "EC2RequestLimitExceeded",
+    "FunctionError.InitTimeout",
+    "FunctionError.RuntimeInitError",
+    "FunctionError.ExtensionInitError",
+    "FunctionError.InvalidEntryPoint",
+    "FunctionError.InvalidWorkingDirectory",
+    "FunctionError.PermissionDenied",
+    "FunctionError.TooManyExtensions",
+    "FunctionError.InitResourceExhausted",
+    "DisallowedByVpcEncryptionControl",
+]
+
+
+# --- restJson1 ser/de ---
+_VALUES: frozenset[str] = frozenset(
+    (
+        "EniLimitExceeded",
+        "InsufficientRolePermissions",
+        "InvalidConfiguration",
+        "InternalError",
+        "SubnetOutOfIPAddresses",
+        "InvalidSubnet",
+        "InvalidSecurityGroup",
+        "ImageDeleted",
+        "ImageAccessDenied",
+        "InvalidImage",
+        "KMSKeyAccessDenied",
+        "KMSKeyNotFound",
+        "InvalidStateKMSKey",
+        "DisabledKMSKey",
+        "EFSIOError",
+        "EFSMountConnectivityError",
+        "EFSMountFailure",
+        "EFSMountTimeout",
+        "InvalidRuntime",
+        "InvalidZipFileException",
+        "FunctionError",
+        "VcpuLimitExceeded",
+        "CapacityProviderScalingLimitExceeded",
+        "InsufficientCapacity",
+        "EC2RequestLimitExceeded",
+        "FunctionError.InitTimeout",
+        "FunctionError.RuntimeInitError",
+        "FunctionError.ExtensionInitError",
+        "FunctionError.InvalidEntryPoint",
+        "FunctionError.InvalidWorkingDirectory",
+        "FunctionError.PermissionDenied",
+        "FunctionError.TooManyExtensions",
+        "FunctionError.InitResourceExhausted",
+        "DisallowedByVpcEncryptionControl",
+    )
+)
+
+
+def serialize_json(value: LastUpdateStatusReasonCode) -> str:
+    return value
+
+
+def deserialize_json(data: str) -> LastUpdateStatusReasonCode:
+    if data not in _VALUES:
+        raise DeserializationError(
+            f"unknown LastUpdateStatusReasonCode value: {data!r}"
+        )
+    return cast(LastUpdateStatusReasonCode, data)

aws_sdk_lambda/types/layer.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#Layer``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.arn
+    import aws_sdk_lambda.types.layer_version_arn
+    import aws_sdk_lambda.types.long
+
+
+class Layer(TypedDict):
+    arn: NotRequired["aws_sdk_lambda.types.layer_version_arn.LayerVersionArn"]
+    """<p>The Amazon Resource Name (ARN) of the function layer.</p>"""
+    code_size: "aws_sdk_lambda.types.long.Long"
+    """<p>The size of the layer archive in bytes.</p>"""
+    signing_profile_version_arn: NotRequired["aws_sdk_lambda.types.arn.Arn"]
+    """<p>The Amazon Resource Name (ARN) for a signing profile version.</p>"""
+    signing_job_arn: NotRequired["aws_sdk_lambda.types.arn.Arn"]
+    """<p>The Amazon Resource Name (ARN) of a signing job.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: Layer) -> dict:
+    out: dict = {}
+    if "arn" in value:
+        out["Arn"] = value["arn"]
+    out["CodeSize"] = value.get("code_size", 0)
+    if "signing_profile_version_arn" in value:
+        out["SigningProfileVersionArn"] = value["signing_profile_version_arn"]
+    if "signing_job_arn" in value:
+        out["SigningJobArn"] = value["signing_job_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> Layer:
+    out: Layer = {}  # type: ignore[typeddict-item]
+    if "Arn" in data:
+        out["arn"] = data["Arn"]
+    if "CodeSize" in data:
+        out["code_size"] = data["CodeSize"]
+    else:
+        out["code_size"] = 0
+    if "SigningProfileVersionArn" in data:
+        out["signing_profile_version_arn"] = data["SigningProfileVersionArn"]
+    if "SigningJobArn" in data:
+        out["signing_job_arn"] = data["SigningJobArn"]
+    return out

aws_sdk_lambda/types/layer_arn.py

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

aws_sdk_lambda/types/layer_list.py

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

aws_sdk_lambda/types/layer_name.py

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

aws_sdk_lambda/types/layer_permission_allowed_action.py

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

aws_sdk_lambda/types/layer_permission_allowed_principal.py

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

aws_sdk_lambda/types/layer_version_arn.py

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

aws_sdk_lambda/types/layer_version_content_input.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#LayerVersionContentInput``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.blob
+    import aws_sdk_lambda.types.s3_bucket
+    import aws_sdk_lambda.types.s3_key
+    import aws_sdk_lambda.types.s3_object_version
+
+
+class LayerVersionContentInput(TypedDict):
+    s3_bucket: NotRequired["aws_sdk_lambda.types.s3_bucket.S3Bucket"]
+    """<p>The Amazon S3 bucket of the layer archive.</p>"""
+    s3_key: NotRequired["aws_sdk_lambda.types.s3_key.S3Key"]
+    """<p>The Amazon S3 key of the layer archive.</p>"""
+    s3_object_version: NotRequired[
+        "aws_sdk_lambda.types.s3_object_version.S3ObjectVersion"
+    ]
+    """<p>For versioned objects, the version of the layer archive object to use.</p>"""
+    zip_file: NotRequired["aws_sdk_lambda.types.blob.Blob"]
+    """<p>The base64-encoded contents of the layer archive. Amazon Web Services SDK and Amazon Web Services CLI clients handle the encoding for you.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: LayerVersionContentInput) -> dict:
+    out: dict = {}
+    if "s3_bucket" in value:
+        out["S3Bucket"] = value["s3_bucket"]
+    if "s3_key" in value:
+        out["S3Key"] = value["s3_key"]
+    if "s3_object_version" in value:
+        out["S3ObjectVersion"] = value["s3_object_version"]
+    if "zip_file" in value:
+        import aws_sdk_lambda.types.blob
+
+        out["ZipFile"] = aws_sdk_lambda.types.blob.serialize_json(value["zip_file"])
+    return out
+
+
+def deserialize_json(data: dict) -> LayerVersionContentInput:
+    out: LayerVersionContentInput = {}  # type: ignore[typeddict-item]
+    if "S3Bucket" in data:
+        out["s3_bucket"] = data["S3Bucket"]
+    if "S3Key" in data:
+        out["s3_key"] = data["S3Key"]
+    if "S3ObjectVersion" in data:
+        out["s3_object_version"] = data["S3ObjectVersion"]
+    if "ZipFile" in data:
+        import aws_sdk_lambda.types.blob
+
+        out["zip_file"] = aws_sdk_lambda.types.blob.deserialize_json(data["ZipFile"])
+    return out

aws_sdk_lambda/types/layer_version_content_output.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#LayerVersionContentOutput``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.long
+    import aws_sdk_lambda.types.string
+
+
+class LayerVersionContentOutput(TypedDict):
+    location: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>A link to the layer archive in Amazon S3 that is valid for 10 minutes.</p>"""
+    code_sha256: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The SHA-256 hash of the layer archive.</p>"""
+    code_size: "aws_sdk_lambda.types.long.Long"
+    """<p>The size of the layer archive in bytes.</p>"""
+    signing_profile_version_arn: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The Amazon Resource Name (ARN) for a signing profile version.</p>"""
+    signing_job_arn: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The Amazon Resource Name (ARN) of a signing job.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: LayerVersionContentOutput) -> dict:
+    out: dict = {}
+    if "location" in value:
+        out["Location"] = value["location"]
+    if "code_sha256" in value:
+        out["CodeSha256"] = value["code_sha256"]
+    out["CodeSize"] = value.get("code_size", 0)
+    if "signing_profile_version_arn" in value:
+        out["SigningProfileVersionArn"] = value["signing_profile_version_arn"]
+    if "signing_job_arn" in value:
+        out["SigningJobArn"] = value["signing_job_arn"]
+    return out
+
+
+def deserialize_json(data: dict) -> LayerVersionContentOutput:
+    out: LayerVersionContentOutput = {}  # type: ignore[typeddict-item]
+    if "Location" in data:
+        out["location"] = data["Location"]
+    if "CodeSha256" in data:
+        out["code_sha256"] = data["CodeSha256"]
+    if "CodeSize" in data:
+        out["code_size"] = data["CodeSize"]
+    else:
+        out["code_size"] = 0
+    if "SigningProfileVersionArn" in data:
+        out["signing_profile_version_arn"] = data["SigningProfileVersionArn"]
+    if "SigningJobArn" in data:
+        out["signing_job_arn"] = data["SigningJobArn"]
+    return out

aws_sdk_lambda/types/layer_version_number.py

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

aws_sdk_lambda/types/layer_versions_list.py

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