capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/operation_update.py

@@ -0,0 +1,174 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#OperationUpdate``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.callback_options
+    import capo_lambda.types.chained_invoke_options
+    import capo_lambda.types.context_options
+    import capo_lambda.types.error_object
+    import capo_lambda.types.operation_action
+    import capo_lambda.types.operation_id
+    import capo_lambda.types.operation_name
+    import capo_lambda.types.operation_payload
+    import capo_lambda.types.operation_sub_type
+    import capo_lambda.types.operation_type
+    import capo_lambda.types.step_options
+    import capo_lambda.types.wait_options
+
+
+class OperationUpdate(TypedDict, closed=True):
+    id: "capo_lambda.types.operation_id.OperationId"
+    """<p>The unique identifier for this operation.</p>"""
+    parent_id: NotRequired["capo_lambda.types.operation_id.OperationId"]
+    """<p>The unique identifier of the parent operation, if this operation is running within a child context.</p>"""
+    name: NotRequired["capo_lambda.types.operation_name.OperationName"]
+    """<p>The customer-provided name for this operation.</p>"""
+    type: "capo_lambda.types.operation_type.OperationType"
+    """<p>The type of operation to update.</p>"""
+    sub_type: NotRequired["capo_lambda.types.operation_sub_type.OperationSubType"]
+    """<p>The subtype of the operation, providing additional categorization.</p>"""
+    action: "capo_lambda.types.operation_action.OperationAction"
+    """<p>The action to take on the operation.</p>"""
+    payload: NotRequired["capo_lambda.types.operation_payload.OperationPayload"]
+    """<p>The payload for successful operations.</p>"""
+    error: NotRequired["capo_lambda.types.error_object.ErrorObject"]
+    """<p>The error information for failed operations.</p>"""
+    context_options: NotRequired["capo_lambda.types.context_options.ContextOptions"]
+    """<p>Options for context operations.</p>"""
+    step_options: NotRequired["capo_lambda.types.step_options.StepOptions"]
+    """<p>Options for step operations.</p>"""
+    wait_options: NotRequired["capo_lambda.types.wait_options.WaitOptions"]
+    """<p>Options for wait operations.</p>"""
+    callback_options: NotRequired["capo_lambda.types.callback_options.CallbackOptions"]
+    chained_invoke_options: NotRequired[
+        "capo_lambda.types.chained_invoke_options.ChainedInvokeOptions"
+    ]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: OperationUpdate) -> dict:
+    out: dict = {}
+    out["Id"] = value["id"]
+    if "parent_id" in value:
+        out["ParentId"] = value["parent_id"]
+    if "name" in value:
+        out["Name"] = value["name"]
+    import capo_lambda.types.operation_type
+
+    out["Type"] = capo_lambda.types.operation_type.serialize_json(value["type"])
+    if "sub_type" in value:
+        out["SubType"] = value["sub_type"]
+    import capo_lambda.types.operation_action
+
+    out["Action"] = capo_lambda.types.operation_action.serialize_json(value["action"])
+    if "payload" in value:
+        out["Payload"] = value["payload"]
+    if "error" in value:
+        import capo_lambda.types.error_object
+
+        out["Error"] = capo_lambda.types.error_object.serialize_json(value["error"])
+    if "context_options" in value:
+        import capo_lambda.types.context_options
+
+        out["ContextOptions"] = capo_lambda.types.context_options.serialize_json(
+            value["context_options"]
+        )
+    if "step_options" in value:
+        import capo_lambda.types.step_options
+
+        out["StepOptions"] = capo_lambda.types.step_options.serialize_json(
+            value["step_options"]
+        )
+    if "wait_options" in value:
+        import capo_lambda.types.wait_options
+
+        out["WaitOptions"] = capo_lambda.types.wait_options.serialize_json(
+            value["wait_options"]
+        )
+    if "callback_options" in value:
+        import capo_lambda.types.callback_options
+
+        out["CallbackOptions"] = capo_lambda.types.callback_options.serialize_json(
+            value["callback_options"]
+        )
+    if "chained_invoke_options" in value:
+        import capo_lambda.types.chained_invoke_options
+
+        out["ChainedInvokeOptions"] = (
+            capo_lambda.types.chained_invoke_options.serialize_json(
+                value["chained_invoke_options"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> OperationUpdate:
+    out: OperationUpdate = {}  # type: ignore[typeddict-item]
+    if "Id" in data:
+        out["id"] = data["Id"]
+    else:
+        raise DeserializationError("OperationUpdate.id required")
+    if "ParentId" in data:
+        out["parent_id"] = data["ParentId"]
+    if "Name" in data:
+        out["name"] = data["Name"]
+    if "Type" in data:
+        import capo_lambda.types.operation_type
+
+        out["type"] = capo_lambda.types.operation_type.deserialize_json(data["Type"])
+    else:
+        raise DeserializationError("OperationUpdate.type required")
+    if "SubType" in data:
+        out["sub_type"] = data["SubType"]
+    if "Action" in data:
+        import capo_lambda.types.operation_action
+
+        out["action"] = capo_lambda.types.operation_action.deserialize_json(
+            data["Action"]
+        )
+    else:
+        raise DeserializationError("OperationUpdate.action required")
+    if "Payload" in data:
+        out["payload"] = data["Payload"]
+    if "Error" in data:
+        import capo_lambda.types.error_object
+
+        out["error"] = capo_lambda.types.error_object.deserialize_json(data["Error"])
+    if "ContextOptions" in data:
+        import capo_lambda.types.context_options
+
+        out["context_options"] = capo_lambda.types.context_options.deserialize_json(
+            data["ContextOptions"]
+        )
+    if "StepOptions" in data:
+        import capo_lambda.types.step_options
+
+        out["step_options"] = capo_lambda.types.step_options.deserialize_json(
+            data["StepOptions"]
+        )
+    if "WaitOptions" in data:
+        import capo_lambda.types.wait_options
+
+        out["wait_options"] = capo_lambda.types.wait_options.deserialize_json(
+            data["WaitOptions"]
+        )
+    if "CallbackOptions" in data:
+        import capo_lambda.types.callback_options
+
+        out["callback_options"] = capo_lambda.types.callback_options.deserialize_json(
+            data["CallbackOptions"]
+        )
+    if "ChainedInvokeOptions" in data:
+        import capo_lambda.types.chained_invoke_options
+
+        out["chained_invoke_options"] = (
+            capo_lambda.types.chained_invoke_options.deserialize_json(
+                data["ChainedInvokeOptions"]
+            )
+        )
+    return out

capo_lambda/types/operation_updates.py

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

capo_lambda/types/operations.py

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

capo_lambda/types/organization_id.py

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

capo_lambda/types/origin.py

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

capo_lambda/types/output_payload.py

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

capo_lambda/types/package_type.py

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

capo_lambda/types/parallelization_factor.py

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

capo_lambda/types/pattern.py

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

capo_lambda/types/per_execution_environment_max_concurrency.py

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

capo_lambda/types/positive_integer.py

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

capo_lambda/types/principal.py

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

capo_lambda/types/principal_org_id.py

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

capo_lambda/types/provisioned_concurrency_config_list.py

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

capo_lambda/types/provisioned_concurrency_config_list_item.py

@@ -0,0 +1,101 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ProvisionedConcurrencyConfigListItem``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_arn
+    import capo_lambda.types.non_negative_integer
+    import capo_lambda.types.positive_integer
+    import capo_lambda.types.provisioned_concurrency_status_enum
+    import capo_lambda.types.string
+    import capo_lambda.types.timestamp
+
+
+class ProvisionedConcurrencyConfigListItem(TypedDict, closed=True):
+    function_arn: NotRequired["capo_lambda.types.function_arn.FunctionArn"]
+    """<p>The Amazon Resource Name (ARN) of the alias or version.</p>"""
+    requested_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.positive_integer.PositiveInteger"
+    ]
+    """<p>The amount of provisioned concurrency requested.</p>"""
+    available_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency available.</p>"""
+    allocated_provisioned_concurrent_executions: NotRequired[
+        "capo_lambda.types.non_negative_integer.NonNegativeInteger"
+    ]
+    """<p>The amount of provisioned concurrency allocated. When a weighted alias is used during linear and canary deployments, this value fluctuates depending on the amount of concurrency that is provisioned for the function versions.</p>"""
+    status: NotRequired[
+        "capo_lambda.types.provisioned_concurrency_status_enum.ProvisionedConcurrencyStatusEnum"
+    ]
+    """<p>The status of the allocation process.</p>"""
+    status_reason: NotRequired["capo_lambda.types.string.String"]
+    """<p>For failed allocations, the reason that provisioned concurrency could not be allocated.</p>"""
+    last_modified: NotRequired["capo_lambda.types.timestamp.Timestamp"]
+    r"""<p>The date and time that a user last updated the configuration, in <a href=\"https://www.iso.org/iso-8601-date-and-time-format.html\">ISO 8601 format</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProvisionedConcurrencyConfigListItem) -> dict:
+    out: dict = {}
+    if "function_arn" in value:
+        out["FunctionArn"] = value["function_arn"]
+    if "requested_provisioned_concurrent_executions" in value:
+        out["RequestedProvisionedConcurrentExecutions"] = value[
+            "requested_provisioned_concurrent_executions"
+        ]
+    if "available_provisioned_concurrent_executions" in value:
+        out["AvailableProvisionedConcurrentExecutions"] = value[
+            "available_provisioned_concurrent_executions"
+        ]
+    if "allocated_provisioned_concurrent_executions" in value:
+        out["AllocatedProvisionedConcurrentExecutions"] = value[
+            "allocated_provisioned_concurrent_executions"
+        ]
+    if "status" in value:
+        import capo_lambda.types.provisioned_concurrency_status_enum
+
+        out["Status"] = (
+            capo_lambda.types.provisioned_concurrency_status_enum.serialize_json(
+                value["status"]
+            )
+        )
+    if "status_reason" in value:
+        out["StatusReason"] = value["status_reason"]
+    if "last_modified" in value:
+        out["LastModified"] = value["last_modified"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProvisionedConcurrencyConfigListItem:
+    out: ProvisionedConcurrencyConfigListItem = {}  # type: ignore[typeddict-item]
+    if "FunctionArn" in data:
+        out["function_arn"] = data["FunctionArn"]
+    if "RequestedProvisionedConcurrentExecutions" in data:
+        out["requested_provisioned_concurrent_executions"] = data[
+            "RequestedProvisionedConcurrentExecutions"
+        ]
+    if "AvailableProvisionedConcurrentExecutions" in data:
+        out["available_provisioned_concurrent_executions"] = data[
+            "AvailableProvisionedConcurrentExecutions"
+        ]
+    if "AllocatedProvisionedConcurrentExecutions" in data:
+        out["allocated_provisioned_concurrent_executions"] = data[
+            "AllocatedProvisionedConcurrentExecutions"
+        ]
+    if "Status" in data:
+        import capo_lambda.types.provisioned_concurrency_status_enum
+
+        out["status"] = (
+            capo_lambda.types.provisioned_concurrency_status_enum.deserialize_json(
+                data["Status"]
+            )
+        )
+    if "StatusReason" in data:
+        out["status_reason"] = data["StatusReason"]
+    if "LastModified" in data:
+        out["last_modified"] = data["LastModified"]
+    return out

capo_lambda/types/provisioned_concurrency_status_enum.py

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

capo_lambda/types/provisioned_poller_config.py

@@ -0,0 +1,48 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ProvisionedPollerConfig``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.maximum_number_of_pollers
+    import capo_lambda.types.minimum_number_of_pollers
+    import capo_lambda.types.provisioned_poller_group_name
+
+
+class ProvisionedPollerConfig(TypedDict, closed=True):
+    minimum_pollers: NotRequired[
+        "capo_lambda.types.minimum_number_of_pollers.MinimumNumberOfPollers"
+    ]
+    """<p>The minimum number of event pollers this event source can scale down to. For Amazon SQS events source mappings, default is 2, and minimum 2 required. For Amazon MSK and self-managed Apache Kafka event source mappings, default is 1.</p>"""
+    maximum_pollers: NotRequired[
+        "capo_lambda.types.maximum_number_of_pollers.MaximumNumberOfPollers"
+    ]
+    """<p>The maximum number of event pollers this event source can scale up to. For Amazon SQS events source mappings, default is 200, and minimum value allowed is 2. For Amazon MSK and self-managed Apache Kafka event source mappings, default is 200, and minimum value allowed is 1.</p>"""
+    poller_group_name: NotRequired[
+        "capo_lambda.types.provisioned_poller_group_name.ProvisionedPollerGroupName"
+    ]
+    """<p>(Amazon MSK and self-managed Apache Kafka) The name of the provisioned poller group. Use this option to group multiple ESMs within the event source's VPC to share Event Poller Unit (EPU) capacity. You can use this option to optimize Provisioned mode costs for your ESMs. You can group up to 100 ESMs per poller group and aggregate maximum pollers across all ESMs in a group cannot exceed 2000.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ProvisionedPollerConfig) -> dict:
+    out: dict = {}
+    if "minimum_pollers" in value:
+        out["MinimumPollers"] = value["minimum_pollers"]
+    if "maximum_pollers" in value:
+        out["MaximumPollers"] = value["maximum_pollers"]
+    if "poller_group_name" in value:
+        out["PollerGroupName"] = value["poller_group_name"]
+    return out
+
+
+def deserialize_json(data: dict) -> ProvisionedPollerConfig:
+    out: ProvisionedPollerConfig = {}  # type: ignore[typeddict-item]
+    if "MinimumPollers" in data:
+        out["minimum_pollers"] = data["MinimumPollers"]
+    if "MaximumPollers" in data:
+        out["maximum_pollers"] = data["MaximumPollers"]
+    if "PollerGroupName" in data:
+        out["poller_group_name"] = data["PollerGroupName"]
+    return out

capo_lambda/types/provisioned_poller_group_name.py

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

capo_lambda/types/publish_layer_version_request.py

@@ -0,0 +1,98 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#PublishLayerVersionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.compatible_architectures
+    import capo_lambda.types.compatible_runtimes
+    import capo_lambda.types.description
+    import capo_lambda.types.layer_name
+    import capo_lambda.types.layer_version_content_input
+    import capo_lambda.types.license_info
+
+
+class PublishLayerVersionRequest(TypedDict, closed=True):
+    layer_name: "capo_lambda.types.layer_name.LayerName"
+    """<p>The name or Amazon Resource Name (ARN) of the layer.</p>"""
+    description: NotRequired["capo_lambda.types.description.Description"]
+    """<p>The description of the version.</p>"""
+    content: "capo_lambda.types.layer_version_content_input.LayerVersionContentInput"
+    """<p>The function layer archive.</p>"""
+    compatible_runtimes: NotRequired[
+        "capo_lambda.types.compatible_runtimes.CompatibleRuntimes"
+    ]
+    r"""<p>A list of compatible <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html\">function runtimes</a>. Used for filtering with <a>ListLayers</a> and <a>ListLayerVersions</a>.</p> <p>The following list includes deprecated runtimes. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtime-support-policy\">Runtime deprecation policy</a>.</p>"""
+    license_info: NotRequired["capo_lambda.types.license_info.LicenseInfo"]
+    r"""<p>The layer's software license. It can be any of the following:</p> <ul> <li> <p>An <a href=\"https://spdx.org/licenses/\">SPDX license identifier</a>. For example, <code>MIT</code>.</p> </li> <li> <p>The URL of a license hosted on the internet. For example, <code>https://opensource.org/licenses/MIT</code>.</p> </li> <li> <p>The full text of the license.</p> </li> </ul>"""
+    compatible_architectures: NotRequired[
+        "capo_lambda.types.compatible_architectures.CompatibleArchitectures"
+    ]
+    r"""<p>A list of compatible <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html\">instruction set architectures</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: PublishLayerVersionRequest) -> dict:
+    out: dict = {}
+    if "description" in value:
+        out["Description"] = value["description"]
+    import capo_lambda.types.layer_version_content_input
+
+    out["Content"] = capo_lambda.types.layer_version_content_input.serialize_json(
+        value["content"]
+    )
+    if "compatible_runtimes" in value:
+        import capo_lambda.types.compatible_runtimes
+
+        out["CompatibleRuntimes"] = (
+            capo_lambda.types.compatible_runtimes.serialize_json(
+                value["compatible_runtimes"]
+            )
+        )
+    if "license_info" in value:
+        out["LicenseInfo"] = value["license_info"]
+    if "compatible_architectures" in value:
+        import capo_lambda.types.compatible_architectures
+
+        out["CompatibleArchitectures"] = (
+            capo_lambda.types.compatible_architectures.serialize_json(
+                value["compatible_architectures"]
+            )
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> PublishLayerVersionRequest:
+    out: PublishLayerVersionRequest = {}  # type: ignore[typeddict-item]
+    if "Description" in data:
+        out["description"] = data["Description"]
+    if "Content" in data:
+        import capo_lambda.types.layer_version_content_input
+
+        out["content"] = capo_lambda.types.layer_version_content_input.deserialize_json(
+            data["Content"]
+        )
+    else:
+        raise DeserializationError("PublishLayerVersionRequest.content required")
+    if "CompatibleRuntimes" in data:
+        import capo_lambda.types.compatible_runtimes
+
+        out["compatible_runtimes"] = (
+            capo_lambda.types.compatible_runtimes.deserialize_json(
+                data["CompatibleRuntimes"]
+            )
+        )
+    if "LicenseInfo" in data:
+        out["license_info"] = data["LicenseInfo"]
+    if "CompatibleArchitectures" in data:
+        import capo_lambda.types.compatible_architectures
+
+        out["compatible_architectures"] = (
+            capo_lambda.types.compatible_architectures.deserialize_json(
+                data["CompatibleArchitectures"]
+            )
+        )
+    return out