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

capo_lambda_web/types/get_web_function_response.py

@@ -0,0 +1,91 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#GetWebFunctionResponse``."""
+
+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.date_time
+    import capo_lambda_web.types.function_arn
+    import capo_lambda_web.types.function_name
+    import capo_lambda_web.types.function_state
+
+
+class GetWebFunctionResponse(TypedDict, closed=True):
+    function_name: "capo_lambda_web.types.function_name.FunctionName"
+    """<p>The name of the web function.</p>"""
+    function_arn: "capo_lambda_web.types.function_arn.FunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the web function.</p>"""
+    state: "capo_lambda_web.types.function_state.FunctionState"
+    """<p>The current state of the web function.</p>"""
+    state_reason: "str"
+    """<p>The reason for the current state of the web function.</p>"""
+    created_at: "capo_lambda_web.types.date_time.DateTime"
+    """<p>The date and time the web function was created.</p>"""
+    updated_at: "capo_lambda_web.types.date_time.DateTime"
+    """<p>The date and time the web function was last updated.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetWebFunctionResponse) -> dict:
+    out: dict = {}
+    out["functionName"] = value["function_name"]
+    out["functionArn"] = value["function_arn"]
+    import capo_lambda_web.types.function_state
+
+    out["state"] = capo_lambda_web.types.function_state.serialize_json(value["state"])
+    out["stateReason"] = value["state_reason"]
+    import capo_lambda_web.types.date_time
+
+    out["createdAt"] = capo_lambda_web.types.date_time.serialize_json(
+        value["created_at"]
+    )
+    import capo_lambda_web.types.date_time
+
+    out["updatedAt"] = capo_lambda_web.types.date_time.serialize_json(
+        value["updated_at"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetWebFunctionResponse:
+    out: GetWebFunctionResponse = {}  # type: ignore[typeddict-item]
+    if data.get("functionName") is not None:
+        out["function_name"] = data["functionName"]
+    else:
+        raise DeserializationError("GetWebFunctionResponse.function_name required")
+    if data.get("functionArn") is not None:
+        out["function_arn"] = data["functionArn"]
+    else:
+        raise DeserializationError("GetWebFunctionResponse.function_arn required")
+    if data.get("state") is not None:
+        import capo_lambda_web.types.function_state
+
+        out["state"] = capo_lambda_web.types.function_state.deserialize_json(
+            data["state"]
+        )
+    else:
+        raise DeserializationError("GetWebFunctionResponse.state required")
+    if data.get("stateReason") is not None:
+        out["state_reason"] = data["stateReason"]
+    else:
+        raise DeserializationError("GetWebFunctionResponse.state_reason required")
+    if data.get("createdAt") is not None:
+        import capo_lambda_web.types.date_time
+
+        out["created_at"] = capo_lambda_web.types.date_time.deserialize_json(
+            data["createdAt"]
+        )
+    else:
+        raise DeserializationError("GetWebFunctionResponse.created_at required")
+    if data.get("updatedAt") is not None:
+        import capo_lambda_web.types.date_time
+
+        out["updated_at"] = capo_lambda_web.types.date_time.deserialize_json(
+            data["updatedAt"]
+        )
+    else:
+        raise DeserializationError("GetWebFunctionResponse.updated_at required")
+    return out

capo_lambda_web/types/get_web_function_revision_request.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#GetWebFunctionRevisionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.function_name
+    import capo_lambda_web.types.revision_id
+
+
+class GetWebFunctionRevisionRequest(TypedDict, closed=True):
+    function_name: "capo_lambda_web.types.function_name.FunctionName"
+    """<p>The name of the web function. You can specify the function name or the function ARN. 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>"""
+    revision_id: "capo_lambda_web.types.revision_id.RevisionId"
+    """<p>The identifier of the revision to retrieve. You can specify the revision identifier or the revision ARN. The length constraint applies only to the full ARN.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetWebFunctionRevisionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> GetWebFunctionRevisionRequest:
+    out: GetWebFunctionRevisionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda_web/types/get_web_function_revision_response.py

@@ -0,0 +1,155 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#GetWebFunctionRevisionResponse``."""
+
+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.date_time
+    import capo_lambda_web.types.description
+    import capo_lambda_web.types.function_arn
+    import capo_lambda_web.types.kms_key_arn
+    import capo_lambda_web.types.revision_arn
+    import capo_lambda_web.types.revision_errors
+    import capo_lambda_web.types.revision_id
+    import capo_lambda_web.types.revision_state
+    import capo_lambda_web.types.service_config
+
+
+class GetWebFunctionRevisionResponse(TypedDict, closed=True):
+    function_arn: "capo_lambda_web.types.function_arn.FunctionArn"
+    """<p>The Amazon Resource Name (ARN) of the web function.</p>"""
+    revision_arn: "capo_lambda_web.types.revision_arn.RevisionArn"
+    """<p>The Amazon Resource Name (ARN) of the revision.</p>"""
+    revision_id: "capo_lambda_web.types.revision_id.RevisionId"
+    """<p>The identifier of the revision.</p>"""
+    description: NotRequired["capo_lambda_web.types.description.Description"]
+    """<p>The 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 KMS key used to encrypt the revision's code and environment variables.</p>"""
+    build_config: "capo_lambda_web.types.build_config.BuildConfig"
+    service_config: "capo_lambda_web.types.service_config.ServiceConfig"
+    state: "capo_lambda_web.types.revision_state.RevisionState"
+    """<p>The current state of the revision.</p>"""
+    state_reason: "str"
+    """<p>The reason for the current state of the revision.</p>"""
+    errors: NotRequired["capo_lambda_web.types.revision_errors.RevisionErrors"]
+    """<p>A list of errors encountered during revision creation. This field is absent when the revision has no errors.</p>"""
+    created_at: "capo_lambda_web.types.date_time.DateTime"
+    """<p>The date and time the revision was created.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: GetWebFunctionRevisionResponse) -> dict:
+    out: dict = {}
+    out["functionArn"] = value["function_arn"]
+    out["revisionArn"] = value["revision_arn"]
+    out["revisionId"] = value["revision_id"]
+    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"]
+    )
+    import capo_lambda_web.types.revision_state
+
+    out["state"] = capo_lambda_web.types.revision_state.serialize_json(value["state"])
+    out["stateReason"] = value["state_reason"]
+    if "errors" in value:
+        import capo_lambda_web.types.revision_errors
+
+        out["errors"] = capo_lambda_web.types.revision_errors.serialize_json(
+            value["errors"]
+        )
+    import capo_lambda_web.types.date_time
+
+    out["createdAt"] = capo_lambda_web.types.date_time.serialize_json(
+        value["created_at"]
+    )
+    return out
+
+
+def deserialize_json(data: dict) -> GetWebFunctionRevisionResponse:
+    out: GetWebFunctionRevisionResponse = {}  # type: ignore[typeddict-item]
+    if data.get("functionArn") is not None:
+        out["function_arn"] = data["functionArn"]
+    else:
+        raise DeserializationError(
+            "GetWebFunctionRevisionResponse.function_arn required"
+        )
+    if data.get("revisionArn") is not None:
+        out["revision_arn"] = data["revisionArn"]
+    else:
+        raise DeserializationError(
+            "GetWebFunctionRevisionResponse.revision_arn required"
+        )
+    if data.get("revisionId") is not None:
+        out["revision_id"] = data["revisionId"]
+    else:
+        raise DeserializationError(
+            "GetWebFunctionRevisionResponse.revision_id required"
+        )
+    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(
+            "GetWebFunctionRevisionResponse.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(
+            "GetWebFunctionRevisionResponse.service_config required"
+        )
+    if data.get("state") is not None:
+        import capo_lambda_web.types.revision_state
+
+        out["state"] = capo_lambda_web.types.revision_state.deserialize_json(
+            data["state"]
+        )
+    else:
+        raise DeserializationError("GetWebFunctionRevisionResponse.state required")
+    if data.get("stateReason") is not None:
+        out["state_reason"] = data["stateReason"]
+    else:
+        raise DeserializationError(
+            "GetWebFunctionRevisionResponse.state_reason required"
+        )
+    if data.get("errors") is not None:
+        import capo_lambda_web.types.revision_errors
+
+        out["errors"] = capo_lambda_web.types.revision_errors.deserialize_json(
+            data["errors"]
+        )
+    if data.get("createdAt") is not None:
+        import capo_lambda_web.types.date_time
+
+        out["created_at"] = capo_lambda_web.types.date_time.deserialize_json(
+            data["createdAt"]
+        )
+    else:
+        raise DeserializationError("GetWebFunctionRevisionResponse.created_at required")
+    return out

capo_lambda_web/types/kms_key_arn.py

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

capo_lambda_web/types/list_tags_request.py

@@ -0,0 +1,24 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListTagsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.resource_arn
+
+
+class ListTagsRequest(TypedDict, closed=True):
+    resource: "capo_lambda_web.types.resource_arn.ResourceArn"
+    """<p>The Amazon Resource Name (ARN) of the web function.</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_web/types/list_tags_response.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListTagsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.tags
+
+
+class ListTagsResponse(TypedDict, closed=True):
+    tags: NotRequired["capo_lambda_web.types.tags.Tags"]
+    """<p>A map of tag keys and values associated with the web function.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListTagsResponse) -> dict:
+    out: dict = {}
+    if "tags" in value:
+        import capo_lambda_web.types.tags
+
+        out["Tags"] = capo_lambda_web.types.tags.serialize_json(value["tags"])
+    return out
+
+
+def deserialize_json(data: dict) -> ListTagsResponse:
+    out: ListTagsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("Tags") is not None:
+        import capo_lambda_web.types.tags
+
+        out["tags"] = capo_lambda_web.types.tags.deserialize_json(data["Tags"])
+    return out

capo_lambda_web/types/list_web_function_endpoints_request.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListWebFunctionEndpointsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.filter_list
+    import capo_lambda_web.types.function_name
+    import capo_lambda_web.types.max_results
+    import capo_lambda_web.types.next_token
+
+
+class ListWebFunctionEndpointsRequest(TypedDict, closed=True):
+    function_name: "capo_lambda_web.types.function_name.FunctionName"
+    """<p>The name of the web function. You can specify the function name or the function ARN. 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>"""
+    filters: NotRequired["capo_lambda_web.types.filter_list.FilterList"]
+    """<p>A list of filters to apply to the results. Supported filter names: <code>authType</code>, <code>autoDeploymentMode</code>, <code>endpointType</code>, <code>state</code>, and <code>updateStatus</code>.</p>"""
+    max_results: "capo_lambda_web.types.max_results.MaxResults"
+    """<p>The maximum number of results to return in a single call. Minimum value of 1, maximum value of 50. Default is 50.</p>"""
+    next_token: NotRequired["capo_lambda_web.types.next_token.NextToken"]
+    """<p>The pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebFunctionEndpointsRequest) -> dict:
+    out: dict = {}
+    if "filters" in value:
+        import capo_lambda_web.types.filter_list
+
+        out["filters"] = capo_lambda_web.types.filter_list.serialize_json(
+            value["filters"]
+        )
+    out["maxResults"] = value.get("max_results", 50)
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebFunctionEndpointsRequest:
+    out: ListWebFunctionEndpointsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("filters") is not None:
+        import capo_lambda_web.types.filter_list
+
+        out["filters"] = capo_lambda_web.types.filter_list.deserialize_json(
+            data["filters"]
+        )
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    else:
+        out["max_results"] = 50
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_lambda_web/types/list_web_function_endpoints_response.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListWebFunctionEndpointsResponse``."""
+
+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.function_endpoint_summary_list
+    import capo_lambda_web.types.next_token
+
+
+class ListWebFunctionEndpointsResponse(TypedDict, closed=True):
+    endpoints: "capo_lambda_web.types.function_endpoint_summary_list.FunctionEndpointSummaryList"
+    """<p>A list of endpoint summaries for the web function.</p>"""
+    next_token: NotRequired["capo_lambda_web.types.next_token.NextToken"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebFunctionEndpointsResponse) -> dict:
+    out: dict = {}
+    import capo_lambda_web.types.function_endpoint_summary_list
+
+    out["endpoints"] = (
+        capo_lambda_web.types.function_endpoint_summary_list.serialize_json(
+            value["endpoints"]
+        )
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebFunctionEndpointsResponse:
+    out: ListWebFunctionEndpointsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("endpoints") is not None:
+        import capo_lambda_web.types.function_endpoint_summary_list
+
+        out["endpoints"] = (
+            capo_lambda_web.types.function_endpoint_summary_list.deserialize_json(
+                data["endpoints"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListWebFunctionEndpointsResponse.endpoints required"
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_lambda_web/types/list_web_function_revisions_request.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListWebFunctionRevisionsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.filter_list
+    import capo_lambda_web.types.function_name
+    import capo_lambda_web.types.max_results
+    import capo_lambda_web.types.next_token
+
+
+class ListWebFunctionRevisionsRequest(TypedDict, closed=True):
+    function_name: "capo_lambda_web.types.function_name.FunctionName"
+    """<p>The name of the web function. You can specify the function name or the function ARN. 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>"""
+    filters: NotRequired["capo_lambda_web.types.filter_list.FilterList"]
+    """<p>A list of filters to apply to the results. The only supported filter name is <code>state</code>.</p>"""
+    max_results: "capo_lambda_web.types.max_results.MaxResults"
+    """<p>The maximum number of results to return in a single call. Minimum value of 1, maximum value of 50. Default is 50.</p>"""
+    next_token: NotRequired["capo_lambda_web.types.next_token.NextToken"]
+    """<p>The pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebFunctionRevisionsRequest) -> dict:
+    out: dict = {}
+    if "filters" in value:
+        import capo_lambda_web.types.filter_list
+
+        out["filters"] = capo_lambda_web.types.filter_list.serialize_json(
+            value["filters"]
+        )
+    out["maxResults"] = value.get("max_results", 50)
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebFunctionRevisionsRequest:
+    out: ListWebFunctionRevisionsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("filters") is not None:
+        import capo_lambda_web.types.filter_list
+
+        out["filters"] = capo_lambda_web.types.filter_list.deserialize_json(
+            data["filters"]
+        )
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    else:
+        out["max_results"] = 50
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_lambda_web/types/list_web_function_revisions_response.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListWebFunctionRevisionsResponse``."""
+
+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.function_revision_summary_list
+    import capo_lambda_web.types.next_token
+
+
+class ListWebFunctionRevisionsResponse(TypedDict, closed=True):
+    revisions: "capo_lambda_web.types.function_revision_summary_list.FunctionRevisionSummaryList"
+    """<p>A list of revision summaries for the web function.</p>"""
+    next_token: NotRequired["capo_lambda_web.types.next_token.NextToken"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebFunctionRevisionsResponse) -> dict:
+    out: dict = {}
+    import capo_lambda_web.types.function_revision_summary_list
+
+    out["revisions"] = (
+        capo_lambda_web.types.function_revision_summary_list.serialize_json(
+            value["revisions"]
+        )
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebFunctionRevisionsResponse:
+    out: ListWebFunctionRevisionsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("revisions") is not None:
+        import capo_lambda_web.types.function_revision_summary_list
+
+        out["revisions"] = (
+            capo_lambda_web.types.function_revision_summary_list.deserialize_json(
+                data["revisions"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListWebFunctionRevisionsResponse.revisions required"
+        )
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_lambda_web/types/list_web_functions_request.py

@@ -0,0 +1,51 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListWebFunctionsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda_web.types.filter_list
+    import capo_lambda_web.types.max_results
+    import capo_lambda_web.types.next_token
+
+
+class ListWebFunctionsRequest(TypedDict, closed=True):
+    filters: NotRequired["capo_lambda_web.types.filter_list.FilterList"]
+    """<p>A list of filters to apply to the results. The only supported filter name is <code>state</code>.</p>"""
+    max_results: "capo_lambda_web.types.max_results.MaxResults"
+    """<p>The maximum number of results to return in a single call. Minimum value of 1, maximum value of 50. Default is 50.</p>"""
+    next_token: NotRequired["capo_lambda_web.types.next_token.NextToken"]
+    """<p>The pagination token that's returned by a previous request to retrieve the next page of results.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebFunctionsRequest) -> dict:
+    out: dict = {}
+    if "filters" in value:
+        import capo_lambda_web.types.filter_list
+
+        out["filters"] = capo_lambda_web.types.filter_list.serialize_json(
+            value["filters"]
+        )
+    out["maxResults"] = value.get("max_results", 50)
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebFunctionsRequest:
+    out: ListWebFunctionsRequest = {}  # type: ignore[typeddict-item]
+    if data.get("filters") is not None:
+        import capo_lambda_web.types.filter_list
+
+        out["filters"] = capo_lambda_web.types.filter_list.deserialize_json(
+            data["filters"]
+        )
+    if data.get("maxResults") is not None:
+        out["max_results"] = data["maxResults"]
+    else:
+        out["max_results"] = 50
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out

capo_lambda_web/types/list_web_functions_response.py

@@ -0,0 +1,46 @@
+"""Generated from Smithy shape ``com.amazonaws.lambdaweb#ListWebFunctionsResponse``."""
+
+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.function_summary_list
+    import capo_lambda_web.types.next_token
+
+
+class ListWebFunctionsResponse(TypedDict, closed=True):
+    functions: "capo_lambda_web.types.function_summary_list.FunctionSummaryList"
+    """<p>A list of web function summaries.</p>"""
+    next_token: NotRequired["capo_lambda_web.types.next_token.NextToken"]
+    """<p>The pagination token that's included if more results are available.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListWebFunctionsResponse) -> dict:
+    out: dict = {}
+    import capo_lambda_web.types.function_summary_list
+
+    out["functions"] = capo_lambda_web.types.function_summary_list.serialize_json(
+        value["functions"]
+    )
+    if "next_token" in value:
+        out["nextToken"] = value["next_token"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListWebFunctionsResponse:
+    out: ListWebFunctionsResponse = {}  # type: ignore[typeddict-item]
+    if data.get("functions") is not None:
+        import capo_lambda_web.types.function_summary_list
+
+        out["functions"] = capo_lambda_web.types.function_summary_list.deserialize_json(
+            data["functions"]
+        )
+    else:
+        raise DeserializationError("ListWebFunctionsResponse.functions required")
+    if data.get("nextToken") is not None:
+        out["next_token"] = data["nextToken"]
+    return out