aws-lambda-powertools 3.8.1a6__py3-none-any.whl → 3.8.1a8__py3-none-any.whl

aws_lambda_powertools/utilities/data_classes/cognito_user_pool_event.py

@@ -9,12 +9,12 @@ class CallerContext(DictWrapper):
     @property
     def aws_sdk_version(self) -> str:
         """The AWS SDK version number."""
-        return self["callerContext"]["awsSdkVersion"]
+        return self["awsSdkVersion"]
 
     @property
     def client_id(self) -> str:
         """The ID of the client associated with the user pool."""
-        return self["callerContext"]["clientId"]
+        return self["clientId"]
 
 
 class BaseTriggerEvent(DictWrapper):
@@ -53,54 +53,54 @@ class BaseTriggerEvent(DictWrapper):
     @property
     def caller_context(self) -> CallerContext:
         """The caller context"""
-        return CallerContext(self._data)
+        return CallerContext(self["callerContext"])
 
 
 class PreSignUpTriggerEventRequest(DictWrapper):
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def validation_data(self) -> dict[str, str]:
         """One or more name-value pairs containing the validation data in the request to register a user."""
-        return self["request"].get("validationData") or {}
+        return self.get("validationData") or {}
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function
         that you specify for the pre sign-up trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class PreSignUpTriggerEventResponse(DictWrapper):
     @property
     def auto_confirm_user(self) -> bool:
-        return bool(self["response"]["autoConfirmUser"])
+        return bool(self["autoConfirmUser"])
 
     @auto_confirm_user.setter
     def auto_confirm_user(self, value: bool):
         """Set to true to auto-confirm the user, or false otherwise."""
-        self["response"]["autoConfirmUser"] = value
+        self._data["autoConfirmUser"] = value
 
     @property
     def auto_verify_email(self) -> bool:
-        return bool(self["response"]["autoVerifyEmail"])
+        return bool(self["autoVerifyEmail"])
 
     @auto_verify_email.setter
     def auto_verify_email(self, value: bool):
         """Set to true to set as verified the email of a user who is signing up, or false otherwise."""
-        self["response"]["autoVerifyEmail"] = value
+        self._data["autoVerifyEmail"] = value
 
     @property
     def auto_verify_phone(self) -> bool:
-        return bool(self["response"]["autoVerifyPhone"])
+        return bool(self["autoVerifyPhone"])
 
     @auto_verify_phone.setter
     def auto_verify_phone(self, value: bool):
         """Set to true to set as verified the phone number of a user who is signing up, or false otherwise."""
-        self["response"]["autoVerifyPhone"] = value
+        self._data["autoVerifyPhone"] = value
 
 
 class PreSignUpTriggerEvent(BaseTriggerEvent):
@@ -121,24 +121,24 @@ class PreSignUpTriggerEvent(BaseTriggerEvent):
 
     @property
     def request(self) -> PreSignUpTriggerEventRequest:
-        return PreSignUpTriggerEventRequest(self._data)
+        return PreSignUpTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> PreSignUpTriggerEventResponse:
-        return PreSignUpTriggerEventResponse(self._data)
+        return PreSignUpTriggerEventResponse(self["response"])
 
 
 class PostConfirmationTriggerEventRequest(DictWrapper):
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function
         that you specify for the post confirmation trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class PostConfirmationTriggerEvent(BaseTriggerEvent):
@@ -158,41 +158,41 @@ class PostConfirmationTriggerEvent(BaseTriggerEvent):
 
     @property
     def request(self) -> PostConfirmationTriggerEventRequest:
-        return PostConfirmationTriggerEventRequest(self._data)
+        return PostConfirmationTriggerEventRequest(self["request"])
 
 
 class UserMigrationTriggerEventRequest(DictWrapper):
     @property
     def password(self) -> str:
-        return self["request"]["password"]
+        return self["password"]
 
     @property
     def validation_data(self) -> dict[str, str]:
         """One or more name-value pairs containing the validation data in the request to register a user."""
-        return self["request"].get("validationData") or {}
+        return self.get("validationData") or {}
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function
         that you specify for the pre sign-up trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class UserMigrationTriggerEventResponse(DictWrapper):
     @property
     def user_attributes(self) -> dict[str, str]:
-        return self["response"]["userAttributes"]
+        return self["userAttributes"]
 
     @user_attributes.setter
     def user_attributes(self, value: dict[str, str]):
         """It must contain one or more name-value pairs representing user attributes to be stored in the
         user profile in your user pool. You can include both standard and custom user attributes.
         Custom attributes require the custom: prefix to distinguish them from standard attributes."""
-        self["response"]["userAttributes"] = value
+        self._data["userAttributes"] = value
 
     @property
     def final_user_status(self) -> str | None:
-        return self["response"].get("finalUserStatus")
+        return self.get("finalUserStatus")
 
     @final_user_status.setter
     def final_user_status(self, value: str):
@@ -202,31 +202,31 @@ class UserMigrationTriggerEventResponse(DictWrapper):
         If this attribute is set to RESET_REQUIRED, the user is required to change his or her password immediately
         after migration at the time of sign-in, and your client app needs to handle the PasswordResetRequiredException
         during the authentication flow."""
-        self["response"]["finalUserStatus"] = value
+        self._data["finalUserStatus"] = value
 
     @property
     def message_action(self) -> str | None:
-        return self["response"].get("messageAction")
+        return self.get("messageAction")
 
     @message_action.setter
     def message_action(self, value: str):
         """This attribute can be set to "SUPPRESS" to suppress the welcome message usually sent by
         Amazon Cognito to new users. If this attribute is not returned, the welcome message will be sent."""
-        self["response"]["messageAction"] = value
+        self._data["messageAction"] = value
 
     @property
     def desired_delivery_mediums(self) -> list[str]:
-        return self["response"].get("desiredDeliveryMediums") or []
+        return self.get("desiredDeliveryMediums") or []
 
     @desired_delivery_mediums.setter
     def desired_delivery_mediums(self, value: list[str]):
         """This attribute can be set to "EMAIL" to send the welcome message by email, or "SMS" to send the
         welcome message by SMS. If this attribute is not returned, the welcome message will be sent by SMS."""
-        self["response"]["desiredDeliveryMediums"] = value
+        self._data["desiredDeliveryMediums"] = value
 
     @property
     def force_alias_creation(self) -> bool | None:
-        return self["response"].get("forceAliasCreation")
+        return self.get("forceAliasCreation")
 
     @force_alias_creation.setter
     def force_alias_creation(self, value: bool):
@@ -239,11 +239,11 @@ class UserMigrationTriggerEventResponse(DictWrapper):
 
         If this attribute is not returned, it is assumed to be "false".
         """
-        self["response"]["forceAliasCreation"] = value
+        self._data["forceAliasCreation"] = value
 
     @property
     def enable_sms_mfa(self) -> bool | None:
-        return self["response"].get("enableSMSMFA")
+        return self.get("enableSMSMFA")
 
     @enable_sms_mfa.setter
     def enable_sms_mfa(self, value: bool):
@@ -251,7 +251,7 @@ class UserMigrationTriggerEventResponse(DictWrapper):
         authentication (MFA) to sign in. Your user pool must have MFA enabled. Your user's attributes
         in the request parameters must include a phone number, or else the migration of that user will fail.
         """
-        self["response"]["enableSMSMFA"] = value
+        self._data["enableSMSMFA"] = value
 
 
 class UserMigrationTriggerEvent(BaseTriggerEvent):
@@ -271,70 +271,70 @@ class UserMigrationTriggerEvent(BaseTriggerEvent):
 
     @property
     def request(self) -> UserMigrationTriggerEventRequest:
-        return UserMigrationTriggerEventRequest(self._data)
+        return UserMigrationTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> UserMigrationTriggerEventResponse:
-        return UserMigrationTriggerEventResponse(self._data)
+        return UserMigrationTriggerEventResponse(self["response"])
 
 
 class CustomMessageTriggerEventRequest(DictWrapper):
     @property
     def code_parameter(self) -> str:
         """A string for you to use as the placeholder for the verification code in the custom message."""
-        return self["request"]["codeParameter"]
+        return self["codeParameter"]
 
     @property
     def link_parameter(self) -> str:
         """A string for you to use as a placeholder for the verification link in the custom message."""
-        return self["request"]["linkParameter"]
+        return self["linkParameter"]
 
     @property
     def username_parameter(self) -> str:
         """The username parameter. It is a required request parameter for the admin create user flow."""
-        return self["request"]["usernameParameter"]
+        return self["usernameParameter"]
 
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function
         that you specify for the pre sign-up trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class CustomMessageTriggerEventResponse(DictWrapper):
     @property
     def sms_message(self) -> str:
-        return self["response"]["smsMessage"]
+        return self["smsMessage"]
 
     @sms_message.setter
     def sms_message(self, value: str):
         """The custom SMS message to be sent to your users.
         Must include the codeParameter value received in the request."""
-        self["response"]["smsMessage"] = value
+        self._data["smsMessage"] = value
 
     @property
     def email_message(self) -> str:
-        return self["response"]["emailMessage"]
+        return self["emailMessage"]
 
     @email_message.setter
     def email_message(self, value: str):
         """The custom email message to be sent to your users.
         Must include the codeParameter value received in the request."""
-        self["response"]["emailMessage"] = value
+        self._data["emailMessage"] = value
 
     @property
     def email_subject(self) -> str:
-        return self["response"]["emailSubject"]
+        return self["emailSubject"]
 
     @email_subject.setter
     def email_subject(self, value: str):
         """The subject line for the custom message."""
-        self["response"]["emailSubject"] = value
+        self._data["emailSubject"] = value
 
 
 class CustomMessageTriggerEvent(BaseTriggerEvent):
@@ -361,28 +361,28 @@ class CustomMessageTriggerEvent(BaseTriggerEvent):
 
     @property
     def request(self) -> CustomMessageTriggerEventRequest:
-        return CustomMessageTriggerEventRequest(self._data)
+        return CustomMessageTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> CustomMessageTriggerEventResponse:
-        return CustomMessageTriggerEventResponse(self._data)
+        return CustomMessageTriggerEventResponse(self["response"])
 
 
 class PreAuthenticationTriggerEventRequest(DictWrapper):
     @property
     def user_not_found(self) -> bool | None:
         """This boolean is populated when PreventUserExistenceErrors is set to ENABLED for your User Pool client."""
-        return self["request"].get("userNotFound")
+        return self.get("userNotFound")
 
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def validation_data(self) -> dict[str, str]:
         """One or more key-value pairs containing the validation data in the user's sign-in request."""
-        return self["request"].get("validationData") or {}
+        return self.get("validationData") or {}
 
 
 class PreAuthenticationTriggerEvent(BaseTriggerEvent):
@@ -405,7 +405,7 @@ class PreAuthenticationTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> PreAuthenticationTriggerEventRequest:
         """Pre Authentication Request Parameters"""
-        return PreAuthenticationTriggerEventRequest(self._data)
+        return PreAuthenticationTriggerEventRequest(self["request"])
 
 
 class PostAuthenticationTriggerEventRequest(DictWrapper):
@@ -413,18 +413,18 @@ class PostAuthenticationTriggerEventRequest(DictWrapper):
     def new_device_used(self) -> bool:
         """This flag indicates if the user has signed in on a new device.
         It is set only if the remembered devices value of the user pool is set to `Always` or User `Opt-In`."""
-        return self["request"]["newDeviceUsed"]
+        return self["newDeviceUsed"]
 
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function
         that you specify for the post authentication trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class PostAuthenticationTriggerEvent(BaseTriggerEvent):
@@ -447,7 +447,7 @@ class PostAuthenticationTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> PostAuthenticationTriggerEventRequest:
         """Post Authentication Request Parameters"""
-        return PostAuthenticationTriggerEventRequest(self._data)
+        return PostAuthenticationTriggerEventRequest(self["request"])
 
 
 class GroupOverrideDetails(DictWrapper):
@@ -471,18 +471,18 @@ class PreTokenGenerationTriggerEventRequest(DictWrapper):
     @property
     def group_configuration(self) -> GroupOverrideDetails:
         """The input object containing the current group configuration"""
-        return GroupOverrideDetails(self["request"]["groupConfiguration"])
+        return GroupOverrideDetails(self["groupConfiguration"])
 
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes."""
-        return self["request"].get("userAttributes") or {}
+        return self.get("userAttributes") or {}
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function
         that you specify for the pre token generation trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class PreTokenGenerationTriggerV2EventRequest(PreTokenGenerationTriggerEventRequest):
@@ -492,10 +492,10 @@ class PreTokenGenerationTriggerV2EventRequest(PreTokenGenerationTriggerEventRequ
         the user pool standard and custom scopes that your user requested,
         and that you authorized your app client to issue.
         """
-        return self["request"].get("scopes")
+        return self.get("scopes") or []
 
 
-class ClaimsOverrideDetails(DictWrapper):
+class ClaimsOverrideBase(DictWrapper):
     @property
     def claims_to_add_or_override(self) -> dict[str, str]:
         return self.get("claimsToAddOrOverride") or {}
@@ -515,6 +515,8 @@ class ClaimsOverrideDetails(DictWrapper):
         """A list that contains claims to be suppressed from the identity token."""
         self._data["claimsToSuppress"] = value
 
+
+class GroupConfigurationBase(DictWrapper):
     @property
     def group_configuration(self) -> GroupOverrideDetails | None:
         group_override_details = self.get("groupOverrideDetails")
@@ -549,26 +551,11 @@ class ClaimsOverrideDetails(DictWrapper):
         self["groupOverrideDetails"]["preferredRole"] = value
 
 
-class TokenClaimsAndScopeOverrideDetails(DictWrapper):
-    @property
-    def claims_to_add_or_override(self) -> dict[str, str]:
-        return self.get("claimsToAddOrOverride") or {}
+class ClaimsOverrideDetails(ClaimsOverrideBase, GroupConfigurationBase):
+    pass
 
-    @claims_to_add_or_override.setter
-    def claims_to_add_or_override(self, value: dict[str, str]):
-        """A map of one or more key-value pairs of claims to add or override.
-        For group related claims, use groupOverrideDetails instead."""
-        self._data["claimsToAddOrOverride"] = value
-
-    @property
-    def claims_to_suppress(self) -> list[str]:
-        return self.get("claimsToSuppress") or []
-
-    @claims_to_suppress.setter
-    def claims_to_suppress(self, value: list[str]):
-        """A list that contains claims to be suppressed from the identity token."""
-        self._data["claimsToSuppress"] = value
 
+class TokenClaimsAndScopeOverrideDetails(ClaimsOverrideBase):
     @property
     def scopes_to_add(self) -> list[str]:
         return self.get("scopesToAdd") or []
@@ -586,8 +573,7 @@ class TokenClaimsAndScopeOverrideDetails(DictWrapper):
         self._data["scopesToSuppress"] = value
 
 
-class ClaimsAndScopeOverrideDetails(DictWrapper):
-
+class ClaimsAndScopeOverrideDetails(GroupConfigurationBase):
     @property
     def id_token_generation(self) -> TokenClaimsAndScopeOverrideDetails | None:
         id_token_generation_details = self._data.get("idTokenGeneration")
@@ -632,56 +618,17 @@ class ClaimsAndScopeOverrideDetails(DictWrapper):
         """
         self._data["accessTokenGeneration"] = value
 
-    @property
-    def group_configuration(self) -> GroupOverrideDetails | None:
-        group_override_details = self.get("groupOverrideDetails")
-        return None if group_override_details is None else GroupOverrideDetails(group_override_details)
-
-    @group_configuration.setter
-    def group_configuration(self, value: dict[str, Any]):
-        """The output object containing the current group configuration.
-
-        It includes groupsToOverride, iamRolesToOverride, and preferredRole.
-
-        The groupOverrideDetails object is replaced with the one you provide. If you provide an empty or null
-        object in the response, then the groups are suppressed. To leave the existing group configuration
-        as is, copy the value of the request's groupConfiguration object to the groupOverrideDetails object
-        in the response, and pass it back to the service.
-        """
-        self._data["groupOverrideDetails"] = value
-
-    def set_group_configuration_groups_to_override(self, value: list[str]):
-        """A list of the group names that are associated with the user that the identity token is issued for."""
-        self._data.setdefault("groupOverrideDetails", {})
-        self["groupOverrideDetails"]["groupsToOverride"] = value
-
-    def set_group_configuration_iam_roles_to_override(self, value: list[str]):
-        """A list of the current IAM roles associated with these groups."""
-        self._data.setdefault("groupOverrideDetails", {})
-        self["groupOverrideDetails"]["iamRolesToOverride"] = value
-
-    def set_group_configuration_preferred_role(self, value: str):
-        """A string indicating the preferred IAM role."""
-        self._data.setdefault("groupOverrideDetails", {})
-        self["groupOverrideDetails"]["preferredRole"] = value
-
 
 class PreTokenGenerationTriggerEventResponse(DictWrapper):
     @property
     def claims_override_details(self) -> ClaimsOverrideDetails:
-        # Ensure we have a `claimsOverrideDetails` element and is not set to None
-        if self._data["response"].get("claimsOverrideDetails") is None:
-            self._data["response"]["claimsOverrideDetails"] = {}
-        return ClaimsOverrideDetails(self._data["response"]["claimsOverrideDetails"])
+        return ClaimsOverrideDetails(self.get("claimsOverrideDetails") or {})
 
 
 class PreTokenGenerationTriggerV2EventResponse(DictWrapper):
     @property
     def claims_scope_override_details(self) -> ClaimsAndScopeOverrideDetails:
-        # Ensure we have a `claimsAndScopeOverrideDetails` element and is not set to None
-        if self._data["response"].get("claimsAndScopeOverrideDetails") is None:
-            self._data["response"]["claimsAndScopeOverrideDetails"] = {}
-        return ClaimsAndScopeOverrideDetails(self._data["response"]["claimsAndScopeOverrideDetails"])
+        return ClaimsAndScopeOverrideDetails(self.get("claimsAndScopeOverrideDetails") or {})
 
 
 class PreTokenGenerationTriggerEvent(BaseTriggerEvent):
@@ -708,12 +655,12 @@ class PreTokenGenerationTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> PreTokenGenerationTriggerEventRequest:
         """Pre Token Generation Request Parameters"""
-        return PreTokenGenerationTriggerEventRequest(self._data)
+        return PreTokenGenerationTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> PreTokenGenerationTriggerEventResponse:
         """Pre Token Generation Response Parameters"""
-        return PreTokenGenerationTriggerEventResponse(self._data)
+        return PreTokenGenerationTriggerEventResponse(self["response"])
 
 
 class PreTokenGenerationV2TriggerEvent(BaseTriggerEvent):
@@ -740,12 +687,12 @@ class PreTokenGenerationV2TriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> PreTokenGenerationTriggerV2EventRequest:
         """Pre Token Generation Request V2 Parameters"""
-        return PreTokenGenerationTriggerV2EventRequest(self._data)
+        return PreTokenGenerationTriggerV2EventRequest(self["request"])
 
     @property
     def response(self) -> PreTokenGenerationTriggerV2EventResponse:
         """Pre Token Generation Response V2 Parameters"""
-        return PreTokenGenerationTriggerV2EventResponse(self._data)
+        return PreTokenGenerationTriggerV2EventResponse(self["response"])
 
 
 class ChallengeResult(DictWrapper):
@@ -772,55 +719,55 @@ class DefineAuthChallengeTriggerEventRequest(DictWrapper):
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def user_not_found(self) -> bool | None:
         """A Boolean that is populated when PreventUserExistenceErrors is set to ENABLED for your user pool client.
         A value of true means that the user id (username, email address, etc.) did not match any existing users."""
-        return self["request"].get("userNotFound")
+        return self.get("userNotFound")
 
     @property
     def session(self) -> list[ChallengeResult]:
         """An array of ChallengeResult elements, each of which contains the following elements:"""
-        return [ChallengeResult(result) for result in self["request"]["session"]]
+        return [ChallengeResult(result) for result in self["session"]]
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function that you specify
         for the defined auth challenge trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class DefineAuthChallengeTriggerEventResponse(DictWrapper):
     @property
     def challenge_name(self) -> str:
-        return self["response"]["challengeName"]
+        return self["challengeName"]
 
     @challenge_name.setter
     def challenge_name(self, value: str):
         """A string containing the name of the next challenge.
         If you want to present a new challenge to your user, specify the challenge name here."""
-        self["response"]["challengeName"] = value
+        self._data["challengeName"] = value
 
     @property
     def fail_authentication(self) -> bool:
-        return bool(self["response"]["failAuthentication"])
+        return bool(self["failAuthentication"])
 
     @fail_authentication.setter
     def fail_authentication(self, value: bool):
         """Set to true if you want to terminate the current authentication process, or false otherwise."""
-        self["response"]["failAuthentication"] = value
+        self._data["failAuthentication"] = value
 
     @property
     def issue_tokens(self) -> bool:
-        return bool(self["response"]["issueTokens"])
+        return bool(self["issueTokens"])
 
     @issue_tokens.setter
     def issue_tokens(self, value: bool):
         """Set to true if you determine that the user has been sufficiently authenticated by
         completing the challenges, or false otherwise."""
-        self["response"]["issueTokens"] = value
+        self._data["issueTokens"] = value
 
 
 class DefineAuthChallengeTriggerEvent(BaseTriggerEvent):
@@ -842,57 +789,57 @@ class DefineAuthChallengeTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> DefineAuthChallengeTriggerEventRequest:
         """Define Auth Challenge Request Parameters"""
-        return DefineAuthChallengeTriggerEventRequest(self._data)
+        return DefineAuthChallengeTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> DefineAuthChallengeTriggerEventResponse:
         """Define Auth Challenge Response Parameters"""
-        return DefineAuthChallengeTriggerEventResponse(self._data)
+        return DefineAuthChallengeTriggerEventResponse(self["response"])
 
 
 class CreateAuthChallengeTriggerEventRequest(DictWrapper):
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def user_not_found(self) -> bool | None:
         """This boolean is populated when PreventUserExistenceErrors is set to ENABLED for your User Pool client."""
-        return self["request"].get("userNotFound")
+        return self.get("userNotFound")
 
     @property
     def challenge_name(self) -> str:
         """The name of the new challenge."""
-        return self["request"]["challengeName"]
+        return self["challengeName"]
 
     @property
     def session(self) -> list[ChallengeResult]:
         """An array of ChallengeResult elements, each of which contains the following elements:"""
-        return [ChallengeResult(result) for result in self["request"]["session"]]
+        return [ChallengeResult(result) for result in self["session"]]
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function that you
         specify for the creation auth challenge trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class CreateAuthChallengeTriggerEventResponse(DictWrapper):
     @property
     def public_challenge_parameters(self) -> dict[str, str]:
-        return self["response"]["publicChallengeParameters"]
+        return self["publicChallengeParameters"]
 
     @public_challenge_parameters.setter
     def public_challenge_parameters(self, value: dict[str, str]):
         """One or more key-value pairs for the client app to use in the challenge to be presented to the user.
         This parameter should contain all the necessary information to accurately present the challenge to
         the user."""
-        self["response"]["publicChallengeParameters"] = value
+        self._data["publicChallengeParameters"] = value
 
     @property
     def private_challenge_parameters(self) -> dict[str, str]:
-        return self["response"]["privateChallengeParameters"]
+        return self["privateChallengeParameters"]
 
     @private_challenge_parameters.setter
     def private_challenge_parameters(self, value: dict[str, str]):
@@ -901,16 +848,16 @@ class CreateAuthChallengeTriggerEventResponse(DictWrapper):
         response to the challenge. In other words, the publicChallengeParameters parameter contains the
         question that is presented to the user and privateChallengeParameters contains the valid answers
         for the question."""
-        self["response"]["privateChallengeParameters"] = value
+        self._data["privateChallengeParameters"] = value
 
     @property
     def challenge_metadata(self) -> str:
-        return self["response"]["challengeMetadata"]
+        return self["challengeMetadata"]
 
     @challenge_metadata.setter
     def challenge_metadata(self, value: str):
         """Your name for the custom challenge, if this is a custom challenge."""
-        self["response"]["challengeMetadata"] = value
+        self._data["challengeMetadata"] = value
 
 
 class CreateAuthChallengeTriggerEvent(BaseTriggerEvent):
@@ -934,52 +881,52 @@ class CreateAuthChallengeTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> CreateAuthChallengeTriggerEventRequest:
         """Create Auth Challenge Request Parameters"""
-        return CreateAuthChallengeTriggerEventRequest(self._data)
+        return CreateAuthChallengeTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> CreateAuthChallengeTriggerEventResponse:
         """Create Auth Challenge Response Parameters"""
-        return CreateAuthChallengeTriggerEventResponse(self._data)
+        return CreateAuthChallengeTriggerEventResponse(self["response"])
 
 
 class VerifyAuthChallengeResponseTriggerEventRequest(DictWrapper):
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def private_challenge_parameters(self) -> dict[str, str]:
         """This parameter comes from the Create Auth Challenge trigger, and is
         compared against a user’s challengeAnswer to determine whether the user passed the challenge."""
-        return self["request"]["privateChallengeParameters"]
+        return self["privateChallengeParameters"]
 
     @property
     def challenge_answer(self) -> Any:
         """The answer from the user's response to the challenge."""
-        return self["request"]["challengeAnswer"]
+        return self["challengeAnswer"]
 
     @property
     def client_metadata(self) -> dict[str, str]:
         """One or more key-value pairs that you can provide as custom input to the Lambda function that
         you specify for the "Verify Auth Challenge" trigger."""
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
     @property
     def user_not_found(self) -> bool | None:
         """This boolean is populated when PreventUserExistenceErrors is set to ENABLED for your User Pool client."""
-        return self["request"].get("userNotFound")
+        return self.get("userNotFound")
 
 
 class VerifyAuthChallengeResponseTriggerEventResponse(DictWrapper):
     @property
     def answer_correct(self) -> bool:
-        return bool(self["response"]["answerCorrect"])
+        return bool(self["answerCorrect"])
 
     @answer_correct.setter
     def answer_correct(self, value: bool):
         """Set to true if the user has successfully completed the challenge, or false otherwise."""
-        self["response"]["answerCorrect"] = value
+        self._data["answerCorrect"] = value
 
 
 class VerifyAuthChallengeResponseTriggerEvent(BaseTriggerEvent):
@@ -1003,12 +950,12 @@ class VerifyAuthChallengeResponseTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> VerifyAuthChallengeResponseTriggerEventRequest:
         """Verify Auth Challenge Request Parameters"""
-        return VerifyAuthChallengeResponseTriggerEventRequest(self._data)
+        return VerifyAuthChallengeResponseTriggerEventRequest(self["request"])
 
     @property
     def response(self) -> VerifyAuthChallengeResponseTriggerEventResponse:
         """Verify Auth Challenge Response Parameters"""
-        return VerifyAuthChallengeResponseTriggerEventResponse(self._data)
+        return VerifyAuthChallengeResponseTriggerEventResponse(self["response"])
 
 
 class CustomEmailSenderTriggerEventRequest(DictWrapper):
@@ -1017,17 +964,17 @@ class CustomEmailSenderTriggerEventRequest(DictWrapper):
         """The request version. For a custom email sender event, the value of this string
         is always customEmailSenderRequestV1.
         """
-        return self["request"]["type"]
+        return self["type"]
 
     @property
     def code(self) -> str:
         """The encrypted code that your function can decrypt and send to your user."""
-        return self["request"]["code"]
+        return self["code"]
 
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"]["userAttributes"]
+        return self["userAttributes"]
 
     @property
     def client_metadata(self) -> dict[str, str]:
@@ -1038,14 +985,14 @@ class CustomEmailSenderTriggerEventRequest(DictWrapper):
         ClientMetadata parameter in AdminInitiateAuth and InitiateAuth API operations
         in the request that it passes to the post authentication function.
         """
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class CustomEmailSenderTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> CustomEmailSenderTriggerEventRequest:
         """Custom Email Sender Request Parameters"""
-        return CustomEmailSenderTriggerEventRequest(self._data)
+        return CustomEmailSenderTriggerEventRequest(self["request"])
 
 
 class CustomSMSSenderTriggerEventRequest(DictWrapper):
@@ -1054,17 +1001,17 @@ class CustomSMSSenderTriggerEventRequest(DictWrapper):
         """The request version. For a custom SMS sender event, the value of this string is always
         customSMSSenderRequestV1.
         """
-        return self["request"]["type"]
+        return self["type"]
 
     @property
     def code(self) -> str:
         """The encrypted code that your function can decrypt and send to your user."""
-        return self["request"]["code"]
+        return self["code"]
 
     @property
     def user_attributes(self) -> dict[str, str]:
         """One or more name-value pairs representing user attributes. The attribute names are the keys."""
-        return self["request"].get("userAttributes") or {}
+        return self.get("userAttributes") or {}
 
     @property
     def client_metadata(self) -> dict[str, str]:
@@ -1075,11 +1022,11 @@ class CustomSMSSenderTriggerEventRequest(DictWrapper):
         ClientMetadata parameter in AdminInitiateAuth and InitiateAuth API operations
         in the request that it passes to the post authentication function.
         """
-        return self["request"].get("clientMetadata") or {}
+        return self.get("clientMetadata") or {}
 
 
 class CustomSMSSenderTriggerEvent(BaseTriggerEvent):
     @property
     def request(self) -> CustomSMSSenderTriggerEventRequest:
         """Custom SMS Sender Request Parameters"""
-        return CustomSMSSenderTriggerEventRequest(self._data)
+        return CustomSMSSenderTriggerEventRequest(self["request"])