capo-lambda 0.5.0__py3-none-any.whl

capo_lambda/types/list_aliases_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListAliasesRequest``."""
+
+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_list_items
+    import capo_lambda.types.string
+    import capo_lambda.types.version_with_latest_published
+
+
+class ListAliasesRequest(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>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>"""
+    function_version: NotRequired[
+        "capo_lambda.types.version_with_latest_published.VersionWithLatestPublished"
+    ]
+    """<p>Specify a function version to only list aliases that invoke that version.</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>Limit the number of aliases returned.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListAliasesRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListAliasesRequest:
+    out: ListAliasesRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_aliases_response.py

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

capo_lambda/types/list_capacity_providers_request.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListCapacityProvidersRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_state
+    import capo_lambda.types.max_fifty_list_items
+    import capo_lambda.types.string
+
+
+class ListCapacityProvidersRequest(TypedDict, closed=True):
+    state: NotRequired[
+        "capo_lambda.types.capacity_provider_state.CapacityProviderState"
+    ]
+    """<p>Filter capacity providers by their current state.</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_fifty_list_items.MaxFiftyListItems"]
+    """<p>The maximum number of capacity providers to return.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListCapacityProvidersRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListCapacityProvidersRequest:
+    out: ListCapacityProvidersRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_capacity_providers_response.py

@@ -0,0 +1,52 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListCapacityProvidersResponse``."""
+
+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_providers_list
+    import capo_lambda.types.string
+
+
+class ListCapacityProvidersResponse(TypedDict, closed=True):
+    capacity_providers: (
+        "capo_lambda.types.capacity_providers_list.CapacityProvidersList"
+    )
+    """<p>A list of capacity providers in your account.</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: ListCapacityProvidersResponse) -> dict:
+    out: dict = {}
+    import capo_lambda.types.capacity_providers_list
+
+    out["CapacityProviders"] = capo_lambda.types.capacity_providers_list.serialize_json(
+        value["capacity_providers"]
+    )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListCapacityProvidersResponse:
+    out: ListCapacityProvidersResponse = {}  # type: ignore[typeddict-item]
+    if "CapacityProviders" in data:
+        import capo_lambda.types.capacity_providers_list
+
+        out["capacity_providers"] = (
+            capo_lambda.types.capacity_providers_list.deserialize_json(
+                data["CapacityProviders"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListCapacityProvidersResponse.capacity_providers required"
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/list_code_signing_configs_request.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListCodeSigningConfigsRequest``."""
+
+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.string
+
+
+class ListCodeSigningConfigsRequest(TypedDict, closed=True):
+    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: ListCodeSigningConfigsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListCodeSigningConfigsRequest:
+    out: ListCodeSigningConfigsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_code_signing_configs_response.py

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

capo_lambda/types/list_durable_executions_by_function_request.py

@@ -0,0 +1,55 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListDurableExecutionsByFunctionRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.durable_execution_name
+    import capo_lambda.types.execution_status_list
+    import capo_lambda.types.execution_timestamp
+    import capo_lambda.types.item_count
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.numeric_latest_published_or_alias_qualifier
+    import capo_lambda.types.reverse_order
+    import capo_lambda.types.string
+
+
+class ListDurableExecutionsByFunctionRequest(TypedDict, closed=True):
+    function_name: "capo_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    """<p>The name or ARN of the Lambda function. You can specify a function name, a partial ARN, or a full ARN.</p>"""
+    qualifier: NotRequired[
+        "capo_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>The function version or alias. If not specified, lists executions for the $LATEST version.</p>"""
+    durable_execution_name: NotRequired[
+        "capo_lambda.types.durable_execution_name.DurableExecutionName"
+    ]
+    """<p>Filter executions by name. Only executions with names that matches this string are returned.</p>"""
+    statuses: NotRequired["capo_lambda.types.execution_status_list.ExecutionStatusList"]
+    """<p>Filter executions by status. Valid values: RUNNING, SUCCEEDED, FAILED, TIMED_OUT, STOPPED.</p>"""
+    started_after: NotRequired[
+        "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    """<p>Filter executions that started after this timestamp (ISO 8601 format).</p>"""
+    started_before: NotRequired[
+        "capo_lambda.types.execution_timestamp.ExecutionTimestamp"
+    ]
+    """<p>Filter executions that started before this timestamp (ISO 8601 format).</p>"""
+    reverse_order: NotRequired["capo_lambda.types.reverse_order.ReverseOrder"]
+    """<p>Set to true to return results in reverse chronological order (newest first). Default is false.</p>"""
+    marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Pagination token from a previous request to continue retrieving results.</p>"""
+    max_items: "capo_lambda.types.item_count.ItemCount"
+    """<p>Maximum number of executions to return (1-1000). Default is 100.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListDurableExecutionsByFunctionRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListDurableExecutionsByFunctionRequest:
+    out: ListDurableExecutionsByFunctionRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_durable_executions_by_function_response.py

@@ -0,0 +1,47 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListDurableExecutionsByFunctionResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.durable_executions
+    import capo_lambda.types.string
+
+
+class ListDurableExecutionsByFunctionResponse(TypedDict, closed=True):
+    durable_executions: NotRequired[
+        "capo_lambda.types.durable_executions.DurableExecutions"
+    ]
+    """<p>List of durable execution summaries matching the filter criteria.</p>"""
+    next_marker: NotRequired["capo_lambda.types.string.String"]
+    """<p>Pagination token for retrieving additional results. Present only if there are more results available.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListDurableExecutionsByFunctionResponse) -> dict:
+    out: dict = {}
+    if "durable_executions" in value:
+        import capo_lambda.types.durable_executions
+
+        out["DurableExecutions"] = capo_lambda.types.durable_executions.serialize_json(
+            value["durable_executions"]
+        )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListDurableExecutionsByFunctionResponse:
+    out: ListDurableExecutionsByFunctionResponse = {}  # type: ignore[typeddict-item]
+    if "DurableExecutions" in data:
+        import capo_lambda.types.durable_executions
+
+        out["durable_executions"] = (
+            capo_lambda.types.durable_executions.deserialize_json(
+                data["DurableExecutions"]
+            )
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/list_event_source_mappings_request.py

@@ -0,0 +1,35 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListEventSourceMappingsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.arn
+    import capo_lambda.types.max_list_items
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.string
+
+
+class ListEventSourceMappingsRequest(TypedDict, closed=True):
+    event_source_arn: NotRequired["capo_lambda.types.arn.Arn"]
+    r"""<p>The Amazon Resource Name (ARN) of the event source.</p> <ul> <li> <p> <b>Amazon Kinesis</b> – The ARN of the data stream or a stream consumer.</p> </li> <li> <p> <b>Amazon DynamoDB Streams</b> – The ARN of the stream.</p> </li> <li> <p> <b>Amazon Simple Queue Service</b> – The ARN of the queue.</p> </li> <li> <p> <b>Amazon Managed Streaming for Apache Kafka</b> – The ARN of the cluster or the ARN of the VPC connection (for <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/with-msk.html#msk-multi-vpc\">cross-account event source mappings</a>).</p> </li> <li> <p> <b>Amazon MQ</b> – The ARN of the broker.</p> </li> <li> <p> <b>Amazon DocumentDB</b> – The ARN of the DocumentDB change stream.</p> </li> </ul>"""
+    function_name: NotRequired[
+        "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>Version or Alias ARN</b> – <code>arn:aws:lambda:us-west-2:123456789012:function:MyFunction:PROD</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's limited to 64 characters in length.</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_list_items.MaxListItems"]
+    """<p>The maximum number of event source mappings to return. Note that ListEventSourceMappings returns a maximum of 100 items in each response, even if you set the number higher.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListEventSourceMappingsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListEventSourceMappingsRequest:
+    out: ListEventSourceMappingsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_event_source_mappings_response.py

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

capo_lambda/types/list_function_event_invoke_configs_request.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionEventInvokeConfigsRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.max_function_event_invoke_config_list_items
+    import capo_lambda.types.namespaced_function_name
+    import capo_lambda.types.string
+
+
+class ListFunctionEventInvokeConfigsRequest(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>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_function_event_invoke_config_list_items.MaxFunctionEventInvokeConfigListItems"
+    ]
+    """<p>The maximum number of configurations to return.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionEventInvokeConfigsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionEventInvokeConfigsRequest:
+    out: ListFunctionEventInvokeConfigsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_function_event_invoke_configs_response.py

@@ -0,0 +1,49 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionEventInvokeConfigsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_event_invoke_config_list
+    import capo_lambda.types.string
+
+
+class ListFunctionEventInvokeConfigsResponse(TypedDict, closed=True):
+    function_event_invoke_configs: NotRequired[
+        "capo_lambda.types.function_event_invoke_config_list.FunctionEventInvokeConfigList"
+    ]
+    """<p>A list of 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: ListFunctionEventInvokeConfigsResponse) -> dict:
+    out: dict = {}
+    if "function_event_invoke_configs" in value:
+        import capo_lambda.types.function_event_invoke_config_list
+
+        out["FunctionEventInvokeConfigs"] = (
+            capo_lambda.types.function_event_invoke_config_list.serialize_json(
+                value["function_event_invoke_configs"]
+            )
+        )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionEventInvokeConfigsResponse:
+    out: ListFunctionEventInvokeConfigsResponse = {}  # type: ignore[typeddict-item]
+    if "FunctionEventInvokeConfigs" in data:
+        import capo_lambda.types.function_event_invoke_config_list
+
+        out["function_event_invoke_configs"] = (
+            capo_lambda.types.function_event_invoke_config_list.deserialize_json(
+                data["FunctionEventInvokeConfigs"]
+            )
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/list_function_url_configs_request.py

@@ -0,0 +1,30 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionUrlConfigsRequest``."""
+
+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_items
+    import capo_lambda.types.string
+
+
+class ListFunctionUrlConfigsRequest(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_items.MaxItems"]
+    """<p>The maximum number of function URLs to return in the response. Note that <code>ListFunctionUrlConfigs</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: ListFunctionUrlConfigsRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionUrlConfigsRequest:
+    out: ListFunctionUrlConfigsRequest = {}  # type: ignore[typeddict-item]
+    return out

capo_lambda/types/list_function_url_configs_response.py

@@ -0,0 +1,54 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionUrlConfigsResponse``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+from capo_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import capo_lambda.types.function_url_config_list
+    import capo_lambda.types.string
+
+
+class ListFunctionUrlConfigsResponse(TypedDict, closed=True):
+    function_url_configs: (
+        "capo_lambda.types.function_url_config_list.FunctionUrlConfigList"
+    )
+    """<p>A list of function URL 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: ListFunctionUrlConfigsResponse) -> dict:
+    out: dict = {}
+    import capo_lambda.types.function_url_config_list
+
+    out["FunctionUrlConfigs"] = (
+        capo_lambda.types.function_url_config_list.serialize_json(
+            value["function_url_configs"]
+        )
+    )
+    if "next_marker" in value:
+        out["NextMarker"] = value["next_marker"]
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionUrlConfigsResponse:
+    out: ListFunctionUrlConfigsResponse = {}  # type: ignore[typeddict-item]
+    if "FunctionUrlConfigs" in data:
+        import capo_lambda.types.function_url_config_list
+
+        out["function_url_configs"] = (
+            capo_lambda.types.function_url_config_list.deserialize_json(
+                data["FunctionUrlConfigs"]
+            )
+        )
+    else:
+        raise DeserializationError(
+            "ListFunctionUrlConfigsResponse.function_url_configs required"
+        )
+    if "NextMarker" in data:
+        out["next_marker"] = data["NextMarker"]
+    return out

capo_lambda/types/list_function_versions_by_capacity_provider_request.py

@@ -0,0 +1,32 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#ListFunctionVersionsByCapacityProviderRequest``."""
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import NotRequired, TypedDict
+
+if TYPE_CHECKING:
+    import capo_lambda.types.capacity_provider_name
+    import capo_lambda.types.max_fifty_list_items
+    import capo_lambda.types.string
+
+
+class ListFunctionVersionsByCapacityProviderRequest(TypedDict, closed=True):
+    capacity_provider_name: (
+        "capo_lambda.types.capacity_provider_name.CapacityProviderName"
+    )
+    """<p>The name of the capacity provider to list function versions for.</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_fifty_list_items.MaxFiftyListItems"]
+    """<p>The maximum number of function versions to return in the response.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: ListFunctionVersionsByCapacityProviderRequest) -> dict:
+    out: dict = {}
+    return out
+
+
+def deserialize_json(data: dict) -> ListFunctionVersionsByCapacityProviderRequest:
+    out: ListFunctionVersionsByCapacityProviderRequest = {}  # type: ignore[typeddict-item]
+    return out