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

aws_sdk_lambda/errors/subnet_ip_address_limit_reached_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#SubnetIPAddressLimitReachedException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class SubnetIPAddressLimitReachedException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: SubnetIPAddressLimitReachedException_) -> dict:
+    out: dict = {}
+    if "type" in value:
+        out["Type"] = value["type"]
+    if "message" in value:
+        out["Message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> SubnetIPAddressLimitReachedException_:
+    out: SubnetIPAddressLimitReachedException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "Message" in data:
+        out["message"] = data["Message"]
+    return out
+
+
+class SubnetIPAddressLimitReachedException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#SubnetIPAddressLimitReachedException``."""
+
+    code: str | None = "SubnetIPAddressLimitReachedException"
+
+    def __init__(self, data: SubnetIPAddressLimitReachedException_):
+        super().__init__(
+            "server",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="SubnetIPAddressLimitReachedException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "SubnetIPAddressLimitReachedException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/too_many_requests_exception.py

@@ -0,0 +1,69 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#TooManyRequestsException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+    import aws_sdk_lambda.types.throttle_reason
+
+
+class TooManyRequestsException_(TypedDict):
+    retry_after_seconds: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The number of seconds the caller should wait before retrying.</p>"""
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+    reason: NotRequired["aws_sdk_lambda.types.throttle_reason.ThrottleReason"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: TooManyRequestsException_) -> dict:
+    out: dict = {}
+    if "type" in value:
+        out["Type"] = value["type"]
+    if "message" in value:
+        out["message"] = value["message"]
+    if "reason" in value:
+        import aws_sdk_lambda.types.throttle_reason
+
+        out["Reason"] = aws_sdk_lambda.types.throttle_reason.serialize_json(
+            value["reason"]
+        )
+    return out
+
+
+def deserialize_json(data: dict) -> TooManyRequestsException_:
+    out: TooManyRequestsException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "message" in data:
+        out["message"] = data["message"]
+    if "Reason" in data:
+        import aws_sdk_lambda.types.throttle_reason
+
+        out["reason"] = aws_sdk_lambda.types.throttle_reason.deserialize_json(
+            data["Reason"]
+        )
+    return out
+
+
+class TooManyRequestsException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#TooManyRequestsException``."""
+
+    code: str | None = "TooManyRequestsException"
+
+    def __init__(self, data: TooManyRequestsException_):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="TooManyRequestsException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "TooManyRequestsException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/errors/unsupported_media_type_exception.py

@@ -0,0 +1,53 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#UnsupportedMediaTypeException``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import ServiceError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class UnsupportedMediaTypeException_(TypedDict):
+    type: NotRequired["aws_sdk_lambda.types.string.String"]
+    message: NotRequired["aws_sdk_lambda.types.string.String"]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: UnsupportedMediaTypeException_) -> dict:
+    out: dict = {}
+    if "type" in value:
+        out["Type"] = value["type"]
+    if "message" in value:
+        out["message"] = value["message"]
+    return out
+
+
+def deserialize_json(data: dict) -> UnsupportedMediaTypeException_:
+    out: UnsupportedMediaTypeException_ = {}  # type: ignore[typeddict-item]
+    if "Type" in data:
+        out["type"] = data["Type"]
+    if "message" in data:
+        out["message"] = data["message"]
+    return out
+
+
+class UnsupportedMediaTypeException(ServiceError):
+    """Modeled error for Smithy shape ``com.amazonaws.lambda#UnsupportedMediaTypeException``."""
+
+    code: str | None = "UnsupportedMediaTypeException"
+
+    def __init__(self, data: UnsupportedMediaTypeException_):
+        super().__init__(
+            "client",
+            is_throttling_error=False,
+            is_retryable=False,
+            code="UnsupportedMediaTypeException",
+        )
+        self.data = data
+
+    @classmethod
+    def from_json(cls, data: dict) -> "UnsupportedMediaTypeException":
+        return cls(deserialize_json(data))

aws_sdk_lambda/types/_prelude/blob.py

@@ -0,0 +1,12 @@
+"""Generated from Smithy prelude shape ``smithy.api#Blob``."""
+
+import base64
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: bytes) -> str:
+    return base64.b64encode(value).decode("ascii")
+
+
+def deserialize_json(data: str) -> bytes:
+    return base64.b64decode(data)

aws_sdk_lambda/types/_prelude/timestamp.py

@@ -0,0 +1,12 @@
+"""Generated from Smithy prelude shape ``smithy.api#Timestamp``."""
+
+import datetime
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: datetime.datetime) -> float:
+    return value.timestamp()
+
+
+def deserialize_json(data: float) -> datetime.datetime:
+    return datetime.datetime.fromtimestamp(float(data), tz=datetime.timezone.utc)

aws_sdk_lambda/types/account_limit.py

@@ -0,0 +1,62 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AccountLimit``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.integer
+    import aws_sdk_lambda.types.long
+    import aws_sdk_lambda.types.unreserved_concurrent_executions
+
+
+class AccountLimit(TypedDict):
+    total_code_size: "aws_sdk_lambda.types.long.Long"
+    """<p>The amount of storage space that you can use for all deployment packages and layer archives.</p>"""
+    code_size_unzipped: "aws_sdk_lambda.types.long.Long"
+    """<p>The maximum size of a function's deployment package and layers when they're extracted.</p>"""
+    code_size_zipped: "aws_sdk_lambda.types.long.Long"
+    """<p>The maximum size of a deployment package when it's uploaded directly to Lambda. Use Amazon S3 for larger files.</p>"""
+    concurrent_executions: "aws_sdk_lambda.types.integer.Integer"
+    """<p>The maximum number of simultaneous function executions.</p>"""
+    unreserved_concurrent_executions: NotRequired[
+        "aws_sdk_lambda.types.unreserved_concurrent_executions.UnreservedConcurrentExecutions"
+    ]
+    """<p>The maximum number of simultaneous function executions, minus the capacity that's reserved for individual functions with <a>PutFunctionConcurrency</a>.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccountLimit) -> dict:
+    out: dict = {}
+    out["TotalCodeSize"] = value.get("total_code_size", 0)
+    out["CodeSizeUnzipped"] = value.get("code_size_unzipped", 0)
+    out["CodeSizeZipped"] = value.get("code_size_zipped", 0)
+    out["ConcurrentExecutions"] = value.get("concurrent_executions", 0)
+    if "unreserved_concurrent_executions" in value:
+        out["UnreservedConcurrentExecutions"] = value[
+            "unreserved_concurrent_executions"
+        ]
+    return out
+
+
+def deserialize_json(data: dict) -> AccountLimit:
+    out: AccountLimit = {}  # type: ignore[typeddict-item]
+    if "TotalCodeSize" in data:
+        out["total_code_size"] = data["TotalCodeSize"]
+    else:
+        out["total_code_size"] = 0
+    if "CodeSizeUnzipped" in data:
+        out["code_size_unzipped"] = data["CodeSizeUnzipped"]
+    else:
+        out["code_size_unzipped"] = 0
+    if "CodeSizeZipped" in data:
+        out["code_size_zipped"] = data["CodeSizeZipped"]
+    else:
+        out["code_size_zipped"] = 0
+    if "ConcurrentExecutions" in data:
+        out["concurrent_executions"] = data["ConcurrentExecutions"]
+    else:
+        out["concurrent_executions"] = 0
+    if "UnreservedConcurrentExecutions" in data:
+        out["unreserved_concurrent_executions"] = data["UnreservedConcurrentExecutions"]
+    return out

aws_sdk_lambda/types/account_usage.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AccountUsage``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.long
+
+
+class AccountUsage(TypedDict):
+    total_code_size: "aws_sdk_lambda.types.long.Long"
+    """<p>The amount of storage space, in bytes, that's being used by deployment packages and layer archives.</p>"""
+    function_count: "aws_sdk_lambda.types.long.Long"
+    """<p>The number of Lambda functions.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AccountUsage) -> dict:
+    out: dict = {}
+    out["TotalCodeSize"] = value.get("total_code_size", 0)
+    out["FunctionCount"] = value.get("function_count", 0)
+    return out
+
+
+def deserialize_json(data: dict) -> AccountUsage:
+    out: AccountUsage = {}  # type: ignore[typeddict-item]
+    if "TotalCodeSize" in data:
+        out["total_code_size"] = data["TotalCodeSize"]
+    else:
+        out["total_code_size"] = 0
+    if "FunctionCount" in data:
+        out["function_count"] = data["FunctionCount"]
+    else:
+        out["function_count"] = 0
+    return out

aws_sdk_lambda/types/action.py

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

aws_sdk_lambda/types/add_layer_version_permission_request.py

@@ -0,0 +1,67 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AddLayerVersionPermissionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.layer_name
+    import aws_sdk_lambda.types.layer_permission_allowed_action
+    import aws_sdk_lambda.types.layer_permission_allowed_principal
+    import aws_sdk_lambda.types.layer_version_number
+    import aws_sdk_lambda.types.organization_id
+    import aws_sdk_lambda.types.statement_id
+    import aws_sdk_lambda.types.string
+
+
+class AddLayerVersionPermissionRequest(TypedDict):
+    layer_name: "aws_sdk_lambda.types.layer_name.LayerName"
+    """<p>The name or Amazon Resource Name (ARN) of the layer.</p>"""
+    version_number: "aws_sdk_lambda.types.layer_version_number.LayerVersionNumber"
+    """<p>The version number.</p>"""
+    statement_id: "aws_sdk_lambda.types.statement_id.StatementId"
+    """<p>An identifier that distinguishes the policy from others on the same layer version.</p>"""
+    action: "aws_sdk_lambda.types.layer_permission_allowed_action.LayerPermissionAllowedAction"
+    """<p>The API action that grants access to the layer. For example, <code>lambda:GetLayerVersion</code>.</p>"""
+    principal: "aws_sdk_lambda.types.layer_permission_allowed_principal.LayerPermissionAllowedPrincipal"
+    """<p>An account ID, or <code>*</code> to grant layer usage permission to all accounts in an organization, or all Amazon Web Services accounts (if <code>organizationId</code> is not specified). For the last case, make sure that you really do want all Amazon Web Services accounts to have usage permission to this layer. </p>"""
+    organization_id: NotRequired["aws_sdk_lambda.types.organization_id.OrganizationId"]
+    """<p>With the principal set to <code>*</code>, grant permission to all accounts in the specified organization.</p>"""
+    revision_id: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>Only update the policy if the revision ID matches the ID specified. Use this option to avoid modifying a policy that has changed since you last read it.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AddLayerVersionPermissionRequest) -> dict:
+    out: dict = {}
+    out["StatementId"] = value["statement_id"]
+    out["Action"] = value["action"]
+    out["Principal"] = value["principal"]
+    if "organization_id" in value:
+        out["OrganizationId"] = value["organization_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> AddLayerVersionPermissionRequest:
+    out: AddLayerVersionPermissionRequest = {}  # type: ignore[typeddict-item]
+    if "StatementId" in data:
+        out["statement_id"] = data["StatementId"]
+    else:
+        raise DeserializationError(
+            "AddLayerVersionPermissionRequest.statement_id required"
+        )
+    if "Action" in data:
+        out["action"] = data["Action"]
+    else:
+        raise DeserializationError("AddLayerVersionPermissionRequest.action required")
+    if "Principal" in data:
+        out["principal"] = data["Principal"]
+    else:
+        raise DeserializationError(
+            "AddLayerVersionPermissionRequest.principal required"
+        )
+    if "OrganizationId" in data:
+        out["organization_id"] = data["OrganizationId"]
+    return out

aws_sdk_lambda/types/add_layer_version_permission_response.py

@@ -0,0 +1,34 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AddLayerVersionPermissionResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class AddLayerVersionPermissionResponse(TypedDict):
+    statement: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The permission statement.</p>"""
+    revision_id: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>A unique identifier for the current revision of the policy.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AddLayerVersionPermissionResponse) -> dict:
+    out: dict = {}
+    if "statement" in value:
+        out["Statement"] = value["statement"]
+    if "revision_id" in value:
+        out["RevisionId"] = value["revision_id"]
+    return out
+
+
+def deserialize_json(data: dict) -> AddLayerVersionPermissionResponse:
+    out: AddLayerVersionPermissionResponse = {}  # type: ignore[typeddict-item]
+    if "Statement" in data:
+        out["statement"] = data["Statement"]
+    if "RevisionId" in data:
+        out["revision_id"] = data["RevisionId"]
+    return out

aws_sdk_lambda/types/add_permission_request.py

@@ -0,0 +1,126 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AddPermissionRequest``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+from aws_sdk_lambda.errors import DeserializationError
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.action
+    import aws_sdk_lambda.types.arn
+    import aws_sdk_lambda.types.event_source_token
+    import aws_sdk_lambda.types.function_url_auth_type
+    import aws_sdk_lambda.types.invoked_via_function_url
+    import aws_sdk_lambda.types.namespaced_function_name
+    import aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier
+    import aws_sdk_lambda.types.principal
+    import aws_sdk_lambda.types.principal_org_id
+    import aws_sdk_lambda.types.source_owner
+    import aws_sdk_lambda.types.statement_id
+    import aws_sdk_lambda.types.string
+
+
+class AddPermissionRequest(TypedDict):
+    function_name: (
+        "aws_sdk_lambda.types.namespaced_function_name.NamespacedFunctionName"
+    )
+    """<p>The name or ARN of the Lambda function, version, or alias.</p> <p class=\"title\"> <b>Name formats</b> </p> <ul> <li> <p> <b>Function name</b> – <code>my-function</code> (name-only), <code>my-function:v1</code> (with alias).</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>You can append a version number or alias to any of the formats. 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>"""
+    statement_id: "aws_sdk_lambda.types.statement_id.StatementId"
+    """<p>A statement identifier that differentiates the statement from others in the same policy.</p>"""
+    action: "aws_sdk_lambda.types.action.Action"
+    """<p>The action that the principal can use on the function. For example, <code>lambda:InvokeFunction</code> or <code>lambda:GetFunction</code>.</p>"""
+    principal: "aws_sdk_lambda.types.principal.Principal"
+    """<p>The Amazon Web Services service, Amazon Web Services account, IAM user, or IAM role that invokes the function. If you specify a service, use <code>SourceArn</code> or <code>SourceAccount</code> to limit who can invoke the function through that service.</p>"""
+    source_arn: NotRequired["aws_sdk_lambda.types.arn.Arn"]
+    """<p>For Amazon Web Services services, the ARN of the Amazon Web Services resource that invokes the function. For example, an Amazon S3 bucket or Amazon SNS topic.</p> <p>Note that Lambda configures the comparison using the <code>StringLike</code> operator.</p>"""
+    source_account: NotRequired["aws_sdk_lambda.types.source_owner.SourceOwner"]
+    """<p>For Amazon Web Services service, the ID of the Amazon Web Services account that owns the resource. Use this together with <code>SourceArn</code> to ensure that the specified account owns the resource. It is possible for an Amazon S3 bucket to be deleted by its owner and recreated by another account.</p>"""
+    event_source_token: NotRequired[
+        "aws_sdk_lambda.types.event_source_token.EventSourceToken"
+    ]
+    """<p>For Alexa Smart Home functions, a token that the invoker must supply.</p>"""
+    qualifier: NotRequired[
+        "aws_sdk_lambda.types.numeric_latest_published_or_alias_qualifier.NumericLatestPublishedOrAliasQualifier"
+    ]
+    """<p>Specify a version or alias to add permissions to a published version of the function.</p>"""
+    revision_id: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>Update the policy only if the revision ID matches the ID that's specified. Use this option to avoid modifying a policy that has changed since you last read it.</p>"""
+    principal_org_id: NotRequired[
+        "aws_sdk_lambda.types.principal_org_id.PrincipalOrgID"
+    ]
+    """<p>The identifier for your organization in Organizations. Use this to grant permissions to all the Amazon Web Services accounts under this organization.</p>"""
+    function_url_auth_type: NotRequired[
+        "aws_sdk_lambda.types.function_url_auth_type.FunctionUrlAuthType"
+    ]
+    """<p>The type of authentication that your function URL uses. Set to <code>AWS_IAM</code> if you want to restrict access to authenticated users only. Set to <code>NONE</code> if you want to bypass IAM authentication to create a public endpoint. For more information, see <a href=\"https://docs.aws.amazon.com/lambda/latest/dg/urls-auth.html\">Control access to Lambda function URLs</a>.</p>"""
+    invoked_via_function_url: NotRequired[
+        "aws_sdk_lambda.types.invoked_via_function_url.InvokedViaFunctionUrl"
+    ]
+    """<p>Indicates whether the permission applies when the function is invoked through a function URL. </p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AddPermissionRequest) -> dict:
+    out: dict = {}
+    out["StatementId"] = value["statement_id"]
+    out["Action"] = value["action"]
+    out["Principal"] = value["principal"]
+    if "source_arn" in value:
+        out["SourceArn"] = value["source_arn"]
+    if "source_account" in value:
+        out["SourceAccount"] = value["source_account"]
+    if "event_source_token" in value:
+        out["EventSourceToken"] = value["event_source_token"]
+    if "revision_id" in value:
+        out["RevisionId"] = value["revision_id"]
+    if "principal_org_id" in value:
+        out["PrincipalOrgID"] = value["principal_org_id"]
+    if "function_url_auth_type" in value:
+        import aws_sdk_lambda.types.function_url_auth_type
+
+        out["FunctionUrlAuthType"] = (
+            aws_sdk_lambda.types.function_url_auth_type.serialize_json(
+                value["function_url_auth_type"]
+            )
+        )
+    if "invoked_via_function_url" in value:
+        out["InvokedViaFunctionUrl"] = value["invoked_via_function_url"]
+    return out
+
+
+def deserialize_json(data: dict) -> AddPermissionRequest:
+    out: AddPermissionRequest = {}  # type: ignore[typeddict-item]
+    if "StatementId" in data:
+        out["statement_id"] = data["StatementId"]
+    else:
+        raise DeserializationError("AddPermissionRequest.statement_id required")
+    if "Action" in data:
+        out["action"] = data["Action"]
+    else:
+        raise DeserializationError("AddPermissionRequest.action required")
+    if "Principal" in data:
+        out["principal"] = data["Principal"]
+    else:
+        raise DeserializationError("AddPermissionRequest.principal required")
+    if "SourceArn" in data:
+        out["source_arn"] = data["SourceArn"]
+    if "SourceAccount" in data:
+        out["source_account"] = data["SourceAccount"]
+    if "EventSourceToken" in data:
+        out["event_source_token"] = data["EventSourceToken"]
+    if "RevisionId" in data:
+        out["revision_id"] = data["RevisionId"]
+    if "PrincipalOrgID" in data:
+        out["principal_org_id"] = data["PrincipalOrgID"]
+    if "FunctionUrlAuthType" in data:
+        import aws_sdk_lambda.types.function_url_auth_type
+
+        out["function_url_auth_type"] = (
+            aws_sdk_lambda.types.function_url_auth_type.deserialize_json(
+                data["FunctionUrlAuthType"]
+            )
+        )
+    if "InvokedViaFunctionUrl" in data:
+        out["invoked_via_function_url"] = data["InvokedViaFunctionUrl"]
+    return out

aws_sdk_lambda/types/add_permission_response.py

@@ -0,0 +1,28 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AddPermissionResponse``."""
+
+from typing import TYPE_CHECKING, TypedDict
+
+from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.string
+
+
+class AddPermissionResponse(TypedDict):
+    statement: NotRequired["aws_sdk_lambda.types.string.String"]
+    """<p>The permission statement that's added to the function policy.</p>"""
+
+
+# --- restJson1 ser/de ---
+def serialize_json(value: AddPermissionResponse) -> dict:
+    out: dict = {}
+    if "statement" in value:
+        out["Statement"] = value["statement"]
+    return out
+
+
+def deserialize_json(data: dict) -> AddPermissionResponse:
+    out: AddPermissionResponse = {}  # type: ignore[typeddict-item]
+    if "Statement" in data:
+        out["statement"] = data["Statement"]
+    return out

aws_sdk_lambda/types/additional_version.py

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

aws_sdk_lambda/types/additional_version_weights.py

@@ -0,0 +1,27 @@
+"""Generated from Smithy shape ``com.amazonaws.lambda#AdditionalVersionWeights``."""
+
+from typing import TYPE_CHECKING, TypeAlias
+
+if TYPE_CHECKING:
+    import aws_sdk_lambda.types.additional_version
+    import aws_sdk_lambda.types.weight
+
+AdditionalVersionWeights: TypeAlias = dict[
+    "aws_sdk_lambda.types.additional_version.AdditionalVersion",
+    "aws_sdk_lambda.types.weight.Weight",
+]
+
+
+# --- restJson1 ser/de ---
+def serialize_json(input_to_serialize: AdditionalVersionWeights) -> dict:
+    out: dict = {}
+    for key, value in input_to_serialize.items():
+        out[key] = value
+    return out
+
+
+def deserialize_json(data: dict) -> AdditionalVersionWeights:
+    out: AdditionalVersionWeights = {}
+    for key, value in data.items():
+        out[key] = value
+    return out

aws_sdk_lambda/types/alias.py

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