capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/list_function_versions_by_capacity_provider_response.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionVersionsByCapacityProviderResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_arn
+    import capo_lambda.types.function_versions_by_capacity_provider_list
+    import capo_lambda.types.string
+
+
+class ListFunctionVersionsByCapacityProviderResponse(TypedDict, closed=True):
+    capacity_provider_arn: "capo_lambda.types.capacity_provider_arn.CapacityProviderArn"
+    """<p>The Amazon Resource Name (ARN) of the capacity provider.</p>"""
+    function_versions: "capo_lambda.types.function_versions_by_capacity_provider_list.FunctionVersionsByCapacityProviderList"
+    """<p>A list of function versions that use the specified capacity provider.</p>"""
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionVersionsByCapacityProviderResponse) -> dict:
+    out: dict = {}
+    out["CapacityProviderArn"] = value["capacity_provider_arn"]
+    import capo_lambda.types.function_versions_by_capacity_provider_list
+
+    out["FunctionVersions"] = (
+        capo_lambda.types.function_versions_by_capacity_provider_list.serialize_json(
+            value["function_versions"]
+        )
+    )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionVersionsByCapacityProviderResponse:
+    out: ListFunctionVersionsByCapacityProviderResponse = {}  # type: ignore[typeddict-item]
+    if "CapacityProviderArn" in data:
+        out["capacity_provider_arn"] = data["CapacityProviderArn"]
+    else:
+        raise DeserializationError(
+            "ListFunctionVersionsByCapacityProviderResponse.capacity_provider_arn required"
+        )
+    if "FunctionVersions" in data:
+        import capo_lambda.types.function_versions_by_capacity_provider_list
+
+        out["function_versions"] = (
+            capo_lambda.types.function_versions_by_capacity_provider_list.deserialize_json(
+                data["FunctionVersions"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListFunctionVersionsByCapacityProviderResponse.function_versions required"
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/list_functions_by_code_signing_config_request.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionsByCodeSigningConfigRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.code_signing_config_arn
+    import capo_lambda.types.max_list_items
+    import capo_lambda.types.string
+
+
+class ListFunctionsByCodeSigningConfigRequest(TypedDict, closed=True):
+    code_signing_config_arn: (
+        "capo_lambda.types.code_signing_config_arn.CodeSigningConfigArn"
+    )
+    """<p>The The Amazon Resource Name (ARN) of the code signing configuration.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Specify the pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+    max_items: NotRequired["capo_lambda.types.max_list_items.MaxListItems"]
+    """<p>Maximum number of items to return.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionsByCodeSigningConfigRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionsByCodeSigningConfigRequest:
+    out: ListFunctionsByCodeSigningConfigRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_functions_by_code_signing_config_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionsByCodeSigningConfigResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_arn_list
+    import capo_lambda.types.string
+
+
+class ListFunctionsByCodeSigningConfigResponse(TypedDict, closed=True):
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+    function_arns: NotRequired["capo_lambda.types.function_arn_list.FunctionArnList"]
+    """<p>The function ARNs. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionsByCodeSigningConfigResponse) -> dict:
+    out: dict = {}
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    if "function_arns" in value:
+        import capo_lambda.types.function_arn_list
+
+        out["FunctionArns"] = capo_lambda.types.function_arn_list.serialize_json(
+            value["function_arns"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionsByCodeSigningConfigResponse:
+    out: ListFunctionsByCodeSigningConfigResponse = {}  # type: ignore[typeddict-item]
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    if "FunctionArns" in data:
+        import capo_lambda.types.function_arn_list
+
+        out["function_arns"] = capo_lambda.types.function_arn_list.deserialize_json(
+            data["FunctionArns"]
+        )
+    return out

capo_lambda/types/list_functions_request.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_version
+    import capo_lambda.types.master_region
+    import capo_lambda.types.max_list_items
+    import capo_lambda.types.string
+
+
+class ListFunctionsRequest(TypedDict, closed=True):
+    master_region: NotRequired["capo_lambda.types.master_region.MasterRegion"]
+    """<p>For Lambda@Edge functions, the Amazon Web Services Region of the master function. For example, <code>us-east-1</code> filters the list of functions to include only Lambda@Edge functions replicated from a master function in US East (N. Virginia). If specified, you must set <code>FunctionVersion</code> to <code>ALL</code>.</p>"""
+    function_version: NotRequired["capo_lambda.types.function_version.FunctionVersion"]
+    """<p>Set to <code>ALL</code> to include entries for all published versions of each function.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Specify the pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+    max_items: NotRequired["capo_lambda.types.max_list_items.MaxListItems"]
+    """<p>The maximum number of functions to return in the response. Note that <code>ListFunctions</code> returns a maximum of 50 items in each response, even if you set the number higher.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionsRequest:
+    out: ListFunctionsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_functions_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_list
+    import capo_lambda.types.string
+
+
+class ListFunctionsResponse(TypedDict, closed=True):
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+    functions: NotRequired["capo_lambda.types.function_list.FunctionList"]
+    """<p>A list of Lambda functions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionsResponse) -> dict:
+    out: dict = {}
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    if "functions" in value:
+        import capo_lambda.types.function_list
+
+        out["Functions"] = capo_lambda.types.function_list.serialize_json(
+            value["functions"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionsResponse:
+    out: ListFunctionsResponse = {}  # type: ignore[typeddict-item]
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    if "Functions" in data:
+        import capo_lambda.types.function_list
+
+        out["functions"] = capo_lambda.types.function_list.deserialize_json(
+            data["Functions"]
+        )
+    return out

capo_lambda/types/list_layer_versions_request.py

@@ -0,0 +1,36 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListLayerVersionsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.architecture
+    import capo_lambda.types.layer_name
+    import capo_lambda.types.max_layer_list_items
+    import capo_lambda.types.runtime
+    import capo_lambda.types.string
+
+
+class ListLayerVersionsRequest(TypedDict, closed=True):
+    compatible_runtime: NotRequired["capo_lambda.types.runtime.Runtime"]
+    r"""<p>A runtime identifier.</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-deprecation-levels\">Runtime use after deprecation</a>.</p> <p>For a list of all currently supported runtimes, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtimes-supported\">Supported runtimes</a>.</p>"""
+    layer_name: "capo_lambda.types.layer_name.LayerName"
+    """<p>The name or Amazon Resource Name (ARN) of the layer.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>A pagination token returned by a previous call.</p>"""
+    max_items: NotRequired["capo_lambda.types.max_layer_list_items.MaxLayerListItems"]
+    """<p>The maximum number of versions to return.</p>"""
+    compatible_architecture: NotRequired["capo_lambda.types.architecture.Architecture"]
+    r"""<p>The compatible <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html\">instruction set architecture</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListLayerVersionsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListLayerVersionsRequest:
+    out: ListLayerVersionsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_layer_versions_response.py

@@ -0,0 +1,45 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListLayerVersionsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.layer_versions_list
+    import capo_lambda.types.string
+
+
+class ListLayerVersionsResponse(TypedDict, closed=True):
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>A pagination token returned when the response doesn't contain all versions.</p>"""
+    layer_versions: NotRequired[
+        "capo_lambda.types.layer_versions_list.LayerVersionsList"
+    ]
+    """<p>A list of versions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListLayerVersionsResponse) -> dict:
+    out: dict = {}
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    if "layer_versions" in value:
+        import capo_lambda.types.layer_versions_list
+
+        out["LayerVersions"] = capo_lambda.types.layer_versions_list.serialize_json(
+            value["layer_versions"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListLayerVersionsResponse:
+    out: ListLayerVersionsResponse = {}  # type: ignore[typeddict-item]
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    if "LayerVersions" in data:
+        import capo_lambda.types.layer_versions_list
+
+        out["layer_versions"] = capo_lambda.types.layer_versions_list.deserialize_json(
+            data["LayerVersions"]
+        )
+    return out

capo_lambda/types/list_layers_request.py

@@ -0,0 +1,33 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListLayersRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.architecture
+    import capo_lambda.types.max_layer_list_items
+    import capo_lambda.types.runtime
+    import capo_lambda.types.string
+
+
+class ListLayersRequest(TypedDict, closed=True):
+    compatible_runtime: NotRequired["capo_lambda.types.runtime.Runtime"]
+    r"""<p>A runtime identifier.</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-deprecation-levels\">Runtime use after deprecation</a>.</p> <p>For a list of all currently supported runtimes, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html#runtimes-supported\">Supported runtimes</a>.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>A pagination token returned by a previous call.</p>"""
+    max_items: NotRequired["capo_lambda.types.max_layer_list_items.MaxLayerListItems"]
+    """<p>The maximum number of layers to return.</p>"""
+    compatible_architecture: NotRequired["capo_lambda.types.architecture.Architecture"]
+    r"""<p>The compatible <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html\">instruction set architecture</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListLayersRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListLayersRequest:
+    out: ListLayersRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_layers_response.py

@@ -0,0 +1,39 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListLayersResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.layers_list
+    import capo_lambda.types.string
+
+
+class ListLayersResponse(TypedDict, closed=True):
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>A pagination token returned when the response doesn't contain all layers.</p>"""
+    layers: NotRequired["capo_lambda.types.layers_list.LayersList"]
+    """<p>A list of function layers.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListLayersResponse) -> dict:
+    out: dict = {}
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    if "layers" in value:
+        import capo_lambda.types.layers_list
+
+        out["Layers"] = capo_lambda.types.layers_list.serialize_json(value["layers"])
+    return out
+
+
+def deserialize_json(data: dict) -> ListLayersResponse:
+    out: ListLayersResponse = {}  # type: ignore[typeddict-item]
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    if "Layers" in data:
+        import capo_lambda.types.layers_list
+
+        out["layers"] = capo_lambda.types.layers_list.deserialize_json(data["Layers"])
+    return out

capo_lambda/types/list_provisioned_concurrency_configs_request.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListProvisionedConcurrencyConfigsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_name
+    import capo_lambda.types.max_provisioned_concurrency_config_list_items
+    import capo_lambda.types.string
+
+
+class ListProvisionedConcurrencyConfigsRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.function_name.FunctionName"
+    r"""<p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code>.</p> </li> <li> <p> <b>Function ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:my-function</code>.</p> </li> <li> <p> <b>Partial ARN</b> – <code>123456789012:function:my-function</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Specify the pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+    max_items: NotRequired[
+        "capo_lambda.types.max_provisioned_concurrency_config_list_items.MaxProvisionedConcurrencyConfigListItems"
+    ]
+    """<p>Specify a number to limit the number of configurations returned.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListProvisionedConcurrencyConfigsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListProvisionedConcurrencyConfigsRequest:
+    out: ListProvisionedConcurrencyConfigsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_provisioned_concurrency_configs_response.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListProvisionedConcurrencyConfigsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.provisioned_concurrency_config_list
+    import capo_lambda.types.string
+
+
+class ListProvisionedConcurrencyConfigsResponse(TypedDict, closed=True):
+    provisioned_concurrency_configs: NotRequired[
+        "capo_lambda.types.provisioned_concurrency_config_list.ProvisionedConcurrencyConfigList"
+    ]
+    """<p>A list of provisioned concurrency configurations.</p>"""
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListProvisionedConcurrencyConfigsResponse) -> dict:
+    out: dict = {}
+    if "provisioned_concurrency_configs" in value:
+        import capo_lambda.types.provisioned_concurrency_config_list
+
+        out["ProvisionedConcurrencyConfigs"] = (
+            capo_lambda.types.provisioned_concurrency_config_list.serialize_json(
+                value["provisioned_concurrency_configs"]
+            )
+        )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListProvisionedConcurrencyConfigsResponse:
+    out: ListProvisionedConcurrencyConfigsResponse = {}  # type: ignore[typeddict-item]
+    if "ProvisionedConcurrencyConfigs" in data:
+        import capo_lambda.types.provisioned_concurrency_config_list
+
+        out["provisioned_concurrency_configs"] = (
+            capo_lambda.types.provisioned_concurrency_config_list.deserialize_json(
+                data["ProvisionedConcurrencyConfigs"]
+            )
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/list_tags_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListTagsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.taggable_resource
+
+
+class ListTagsRequest(TypedDict, closed=True):
+    resource: "capo_lambda.types.taggable_resource.TaggableResource"
+    """<p>The resource's Amazon Resource Name (ARN). Note: Lambda does not support adding tags to function aliases or versions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListTagsRequest:
+    out: ListTagsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_tags_response.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListTagsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.tags
+
+
+class ListTagsResponse(TypedDict, closed=True):
+    tags: NotRequired["capo_lambda.types.tags.Tags"]
+    """<p>The function's tags.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsResponse) -> dict:
+    out: dict = {}
+    if "tags" in value:
+        import capo_lambda.types.tags
+
+        out["Tags"] = capo_lambda.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> ListTagsResponse:
+    out: ListTagsResponse = {}  # type: ignore[typeddict-item]
+    if "Tags" in data:
+        import capo_lambda.types.tags
+
+        out["tags"] = capo_lambda.types.tags.deserialize_json(data["Tags"])
+    return out

capo_lambda/types/list_versions_by_function_request.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListVersionsByFunctionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.max_list_items
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.string
+
+
+class ListVersionsByFunctionRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    r"""<p>The name or ARN of the Lambda function.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> - <code>MyFunction</code>.</p> </li> <li> <p> <b>Function ARN</b> - <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction</code>.</p> </li> <li> <p> <b>Partial ARN</b> - <code>123456789012:function:MyFunction</code>.</p> </li> </ul> <p>The length constraint applies only to the full ARN. If you specify only the function name, it is limited to 64 characters in length.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Specify the pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+    max_items: NotRequired["capo_lambda.types.max_list_items.MaxListItems"]
+    """<p>The maximum number of versions to return. Note that <code>ListVersionsByFunction</code> returns a maximum of 50 items in each response, even if you set the number higher.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListVersionsByFunctionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListVersionsByFunctionRequest:
+    out: ListVersionsByFunctionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_versions_by_function_response.py

@@ -0,0 +1,43 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListVersionsByFunctionResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_list
+    import capo_lambda.types.string
+
+
+class ListVersionsByFunctionResponse(TypedDict, closed=True):
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+    versions: NotRequired["capo_lambda.types.function_list.FunctionList"]
+    """<p>A list of Lambda function versions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListVersionsByFunctionResponse) -> dict:
+    out: dict = {}
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    if "versions" in value:
+        import capo_lambda.types.function_list
+
+        out["Versions"] = capo_lambda.types.function_list.serialize_json(
+            value["versions"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> ListVersionsByFunctionResponse:
+    out: ListVersionsByFunctionResponse = {}  # type: ignore[typeddict-item]
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    if "Versions" in data:
+        import capo_lambda.types.function_list
+
+        out["versions"] = capo_lambda.types.function_list.deserialize_json(
+            data["Versions"]
+        )
+    return out

capo_lambda/types/local_mount_path.py

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

capo_lambda/types/log_format.py

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

capo_lambda/types/log_group.py

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

capo_lambda/types/log_type.py

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