• Home
• io.github.vigoo
• zio-aws-cognitoidentityprovider_2.12
• 3.17.75.1
• source code
• package.scala

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.github.vigoo.zioaws.cognitoidentityprovider.package.scala Maven / Gradle / Ivy

package io.github.vigoo.zioaws
import io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserMfaPreferenceResponse.ReadOnly
import io.github.vigoo.zioaws.cognitoidentityprovider.CognitoIdentityProvider
import io.github.vigoo.zioaws.core.{AwsServiceBase, AwsError}
import software.amazon.awssdk.services.cognitoidentityprovider.paginators.ListUsersPublisher
import io.github.vigoo.zioaws.cognitoidentityprovider.model.{
  CreateResourceServerRequest,
  GetCsvHeaderRequest,
  DeleteUserRequest,
  SignUpRequest,
  AssociateSoftwareTokenRequest,
  CreateUserPoolDomainRequest,
  ForgetDeviceRequest,
  DeleteUserPoolRequest,
  SetUserMfaPreferenceRequest,
  ChangePasswordRequest,
  AdminDeleteUserAttributesRequest,
  AdminSetUserMfaPreferenceRequest,
  InitiateAuthRequest,
  AdminSetUserPasswordRequest,
  UpdateUserPoolRequest,
  AddCustomAttributesRequest,
  RespondToAuthChallengeRequest,
  GetUserAttributeVerificationCodeRequest,
  ListResourceServersRequest,
  UpdateUserAttributesRequest,
  ResendConfirmationCodeRequest,
  ConfirmSignUpRequest,
  ConfirmDeviceRequest,
  AdminDisableProviderForUserRequest,
  GetIdentityProviderByIdentifierRequest,
  GetGroupRequest,
  DescribeIdentityProviderRequest,
  ListUsersRequest,
  ListUserPoolClientsRequest,
  GetUserPoolMfaConfigRequest,
  AdminUserGlobalSignOutRequest,
  AdminForgetDeviceRequest,
  UpdateGroupRequest,
  StopUserImportJobRequest,
  ListUserImportJobsRequest,
  SetUserSettingsRequest,
  AdminUpdateAuthEventFeedbackRequest,
  ListIdentityProvidersRequest,
  CreateIdentityProviderRequest,
  SetUiCustomizationRequest,
  CreateUserPoolRequest,
  AdminLinkProviderForUserRequest,
  GetDeviceRequest,
  ConfirmForgotPasswordRequest,
  AdminInitiateAuthRequest,
  DescribeUserPoolRequest,
  ListTagsForResourceRequest,
  SetUserPoolMfaConfigRequest,
  AdminListGroupsForUserRequest,
  DescribeUserPoolClientRequest,
  AdminDisableUserRequest,
  DeleteGroupRequest,
  AdminGetDeviceRequest,
  AdminConfirmSignUpRequest,
  CreateUserImportJobRequest,
  ListGroupsRequest,
  GetUiCustomizationRequest,
  UpdateDeviceStatusRequest,
  GlobalSignOutRequest,
  StartUserImportJobRequest,
  UpdateUserPoolDomainRequest,
  AdminEnableUserRequest,
  VerifyUserAttributeRequest,
  AdminGetUserRequest,
  AdminListDevicesRequest,
  DescribeUserImportJobRequest,
  UpdateIdentityProviderRequest,
  DeleteUserPoolClientRequest,
  GetUserRequest,
  DeleteResourceServerRequest,
  AdminListUserAuthEventsRequest,
  DeleteUserPoolDomainRequest,
  ListUserPoolsRequest,
  CreateUserPoolClientRequest,
  UntagResourceRequest,
  AdminAddUserToGroupRequest,
  SetRiskConfigurationRequest,
  ListUsersInGroupRequest,
  DescribeUserPoolDomainRequest,
  ForgotPasswordRequest,
  AdminRespondToAuthChallengeRequest,
  CreateGroupRequest,
  AdminResetUserPasswordRequest,
  AdminRemoveUserFromGroupRequest,
  ListDevicesRequest,
  RevokeTokenRequest,
  VerifySoftwareTokenRequest,
  AdminUpdateDeviceStatusRequest,
  AdminCreateUserRequest,
  DescribeRiskConfigurationRequest,
  GetSigningCertificateRequest,
  DeleteUserAttributesRequest,
  UpdateUserPoolClientRequest,
  UpdateResourceServerRequest,
  AdminDeleteUserRequest,
  TagResourceRequest,
  DescribeResourceServerRequest,
  AdminUpdateUserAttributesRequest,
  DeleteIdentityProviderRequest,
  AdminSetUserSettingsRequest,
  UpdateAuthEventFeedbackRequest
}
import io.github.vigoo.zioaws.core.config.AwsConfig
import zio.{ZManaged, IO, ZIO, ZLayer, URLayer, Has}
import io.github.vigoo.zioaws.core.aspects.{AwsCallAspect, AspectSupport}
import software.amazon.awssdk.services.cognitoidentityprovider.{
  CognitoIdentityProviderAsyncClientBuilder,
  CognitoIdentityProviderAsyncClient
}
import zio.stream.ZStream
import software.amazon.awssdk.services.cognitoidentityprovider.model.{
  DeleteGroupResponse,
  ListUserImportJobsResponse,
  UserType,
  AdminUpdateUserAttributesResponse,
  AdminRemoveUserFromGroupResponse,
  AdminInitiateAuthResponse,
  DescribeIdentityProviderResponse,
  SetUiCustomizationResponse,
  AdminGetDeviceResponse,
  StopUserImportJobResponse,
  GetUiCustomizationResponse,
  DeleteUserPoolClientResponse,
  ResendConfirmationCodeResponse,
  AdminAddUserToGroupResponse,
  AssociateSoftwareTokenResponse,
  AdminListUserAuthEventsResponse,
  VerifyUserAttributeResponse,
  GetSigningCertificateResponse,
  AdminForgetDeviceResponse,
  CreateResourceServerResponse,
  AdminListGroupsForUserResponse,
  ListUsersInGroupResponse,
  UpdateResourceServerResponse,
  ListIdentityProvidersResponse,
  DeleteUserAttributesResponse,
  AdminGetUserResponse,
  UpdateAuthEventFeedbackResponse,
  AdminRespondToAuthChallengeResponse,
  ListUserPoolClientsResponse,
  DescribeRiskConfigurationResponse,
  ForgetDeviceResponse,
  AddCustomAttributesResponse,
  AdminUserGlobalSignOutResponse,
  AdminResetUserPasswordResponse,
  DescribeUserPoolClientResponse,
  UserPoolClientDescription,
  AdminEnableUserResponse,
  UpdateIdentityProviderResponse,
  ListDevicesResponse,
  UpdateDeviceStatusResponse,
  CreateUserImportJobResponse,
  AdminListDevicesResponse,
  GetUserResponse,
  SetRiskConfigurationResponse,
  ListUserPoolsResponse,
  ConfirmDeviceResponse,
  AdminDeleteUserAttributesResponse,
  CreateUserPoolResponse,
  AdminUpdateAuthEventFeedbackResponse,
  AdminConfirmSignUpResponse,
  ListTagsForResourceResponse,
  UntagResourceResponse,
  SetUserSettingsResponse,
  AdminLinkProviderForUserResponse,
  DescribeUserPoolResponse,
  AdminSetUserPasswordResponse,
  DescribeUserImportJobResponse,
  GetDeviceResponse,
  UpdateUserPoolClientResponse,
  UpdateUserPoolResponse,
  DescribeResourceServerResponse,
  UserPoolDescriptionType,
  AdminSetUserSettingsResponse,
  UpdateUserAttributesResponse,
  ListResourceServersResponse,
  ConfirmForgotPasswordResponse,
  ResourceServerType,
  ListGroupsResponse,
  GetIdentityProviderByIdentifierResponse,
  DeleteResourceServerResponse,
  GetCsvHeaderResponse,
  AdminDeleteUserResponse,
  UpdateUserPoolDomainResponse,
  GlobalSignOutResponse,
  SignUpResponse,
  RevokeTokenResponse,
  RespondToAuthChallengeResponse,
  CreateIdentityProviderResponse,
  ProviderDescription,
  CreateGroupResponse,
  ChangePasswordResponse,
  GetUserAttributeVerificationCodeResponse,
  DeleteUserResponse,
  StartUserImportJobResponse,
  AdminSetUserMfaPreferenceResponse,
  AdminDisableProviderForUserResponse,
  AdminCreateUserResponse,
  AdminUpdateDeviceStatusResponse,
  DeleteUserPoolResponse,
  SetUserMfaPreferenceResponse,
  AdminDisableUserResponse,
  AuthEventType,
  ConfirmSignUpResponse,
  CreateUserPoolClientResponse,
  SetUserPoolMfaConfigResponse,
  TagResourceResponse,
  DeleteUserPoolDomainResponse,
  DescribeUserPoolDomainResponse,
  DeleteIdentityProviderResponse,
  GroupType,
  GetGroupResponse,
  CreateUserPoolDomainResponse,
  GetUserPoolMfaConfigResponse,
  ForgotPasswordResponse,
  UpdateGroupResponse,
  InitiateAuthResponse,
  VerifySoftwareTokenResponse
}
import zio.test.mock.{Proxy, Mock}
package object cognitoidentityprovider {
  import scala.jdk.CollectionConverters._
  type CognitoIdentityProvider = Has[CognitoIdentityProvider.Service]
  object CognitoIdentityProvider {
    trait Service extends AspectSupport[Service] {
      val api: CognitoIdentityProviderAsyncClient
      def adminConfirmSignUp(request: AdminConfirmSignUpRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminConfirmSignUpResponse.ReadOnly
      ]
      def createIdentityProvider(request: CreateIdentityProviderRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateIdentityProviderResponse.ReadOnly
      ]
      def adminEnableUser(request: AdminEnableUserRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminEnableUserResponse.ReadOnly
      ]
      def revokeToken(request: RevokeTokenRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.RevokeTokenResponse.ReadOnly
      ]
      def stopUserImportJob(request: StopUserImportJobRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.StopUserImportJobResponse.ReadOnly
      ]
      def adminRemoveUserFromGroup(
          request: AdminRemoveUserFromGroupRequest
      ): IO[AwsError, Unit]
      def describeUserPoolDomain(request: DescribeUserPoolDomainRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolDomainResponse.ReadOnly
      ]
      def listUsers(request: ListUsersRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
      ]
      def listUsersInGroup(request: ListUsersInGroupRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
      ]
      def globalSignOut(request: GlobalSignOutRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GlobalSignOutResponse.ReadOnly
      ]
      def adminGetUser(request: AdminGetUserRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetUserResponse.ReadOnly
      ]
      def createUserPoolDomain(request: CreateUserPoolDomainRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolDomainResponse.ReadOnly
      ]
      def associateSoftwareToken(request: AssociateSoftwareTokenRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AssociateSoftwareTokenResponse.ReadOnly
      ]
      def adminUpdateAuthEventFeedback(
          request: AdminUpdateAuthEventFeedbackRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackResponse.ReadOnly
      ]
      def describeUserPool(request: DescribeUserPoolRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolResponse.ReadOnly
      ]
      def describeIdentityProvider(
          request: DescribeIdentityProviderRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeIdentityProviderResponse.ReadOnly
      ]
      def adminUpdateDeviceStatus(request: AdminUpdateDeviceStatusRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateDeviceStatusResponse.ReadOnly
      ]
      def adminUpdateUserAttributes(
          request: AdminUpdateUserAttributesRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateUserAttributesResponse.ReadOnly
      ]
      def resendConfirmationCode(request: ResendConfirmationCodeRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ResendConfirmationCodeResponse.ReadOnly
      ]
      def signUp(request: SignUpRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SignUpResponse.ReadOnly
      ]
      def deleteIdentityProvider(
          request: DeleteIdentityProviderRequest
      ): IO[AwsError, Unit]
      def getUserAttributeVerificationCode(
          request: GetUserAttributeVerificationCodeRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserAttributeVerificationCodeResponse.ReadOnly
      ]
      def deleteUserPoolClient(
          request: DeleteUserPoolClientRequest
      ): IO[AwsError, Unit]
      def deleteGroup(request: DeleteGroupRequest): IO[AwsError, Unit]
      def adminSetUserSettings(request: AdminSetUserSettingsRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserSettingsResponse.ReadOnly
      ]
      def getSigningCertificate(request: GetSigningCertificateRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetSigningCertificateResponse.ReadOnly
      ]
      def getUserPoolMfaConfig(request: GetUserPoolMfaConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserPoolMfaConfigResponse.ReadOnly
      ]
      def updateUserPoolClient(request: UpdateUserPoolClientRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolClientResponse.ReadOnly
      ]
      def initiateAuth(request: InitiateAuthRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.InitiateAuthResponse.ReadOnly
      ]
      def changePassword(request: ChangePasswordRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ChangePasswordResponse.ReadOnly
      ]
      def adminListGroupsForUser(
          request: AdminListGroupsForUserRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
      ]
      def deleteUserAttributes(request: DeleteUserAttributesRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserAttributesResponse.ReadOnly
      ]
      def adminResetUserPassword(request: AdminResetUserPasswordRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminResetUserPasswordResponse.ReadOnly
      ]
      def addCustomAttributes(request: AddCustomAttributesRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AddCustomAttributesResponse.ReadOnly
      ]
      def adminUserGlobalSignOut(request: AdminUserGlobalSignOutRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUserGlobalSignOutResponse.ReadOnly
      ]
      def getUICustomization(request: GetUiCustomizationRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUiCustomizationResponse.ReadOnly
      ]
      def createResourceServer(request: CreateResourceServerRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateResourceServerResponse.ReadOnly
      ]
      def adminDisableUser(request: AdminDisableUserRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableUserResponse.ReadOnly
      ]
      def respondToAuthChallenge(request: RespondToAuthChallengeRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.RespondToAuthChallengeResponse.ReadOnly
      ]
      def getUser(request: GetUserRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserResponse.ReadOnly
      ]
      def deleteResourceServer(
          request: DeleteResourceServerRequest
      ): IO[AwsError, Unit]
      def listGroups(request: ListGroupsRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
      ]
      def listDevices(request: ListDevicesRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ListDevicesResponse.ReadOnly
      ]
      def verifySoftwareToken(request: VerifySoftwareTokenRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifySoftwareTokenResponse.ReadOnly
      ]
      def adminDisableProviderForUser(
          request: AdminDisableProviderForUserRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableProviderForUserResponse.ReadOnly
      ]
      def forgotPassword(request: ForgotPasswordRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ForgotPasswordResponse.ReadOnly
      ]
      def updateAuthEventFeedback(request: UpdateAuthEventFeedbackRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateAuthEventFeedbackResponse.ReadOnly
      ]
      def updateIdentityProvider(request: UpdateIdentityProviderRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateIdentityProviderResponse.ReadOnly
      ]
      def listUserPoolClients(request: ListUserPoolClientsRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolClientDescription.ReadOnly
      ]
      def startUserImportJob(request: StartUserImportJobRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.StartUserImportJobResponse.ReadOnly
      ]
      def updateUserAttributes(request: UpdateUserAttributesRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserAttributesResponse.ReadOnly
      ]
      def adminListUserAuthEvents(
          request: AdminListUserAuthEventsRequest
      ): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AuthEventType.ReadOnly
      ]
      def listIdentityProviders(request: ListIdentityProvidersRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ProviderDescription.ReadOnly
      ]
      def listUserImportJobs(request: ListUserImportJobsRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ListUserImportJobsResponse.ReadOnly
      ]
      def adminCreateUser(request: AdminCreateUserRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminCreateUserResponse.ReadOnly
      ]
      def adminInitiateAuth(request: AdminInitiateAuthRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminInitiateAuthResponse.ReadOnly
      ]
      def confirmSignUp(request: ConfirmSignUpRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmSignUpResponse.ReadOnly
      ]
      def adminGetDevice(request: AdminGetDeviceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetDeviceResponse.ReadOnly
      ]
      def adminLinkProviderForUser(
          request: AdminLinkProviderForUserRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminLinkProviderForUserResponse.ReadOnly
      ]
      def confirmForgotPassword(request: ConfirmForgotPasswordRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmForgotPasswordResponse.ReadOnly
      ]
      def setRiskConfiguration(request: SetRiskConfigurationRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetRiskConfigurationResponse.ReadOnly
      ]
      def forgetDevice(request: ForgetDeviceRequest): IO[AwsError, Unit]
      def deleteUserPool(request: DeleteUserPoolRequest): IO[AwsError, Unit]
      def untagResource(request: UntagResourceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UntagResourceResponse.ReadOnly
      ]
      def listResourceServers(request: ListResourceServersRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ResourceServerType.ReadOnly
      ]
      def describeUserImportJob(request: DescribeUserImportJobRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserImportJobResponse.ReadOnly
      ]
      def deleteUserPoolDomain(request: DeleteUserPoolDomainRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserPoolDomainResponse.ReadOnly
      ]
      def setUserSettings(request: SetUserSettingsRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserSettingsResponse.ReadOnly
      ]
      def adminDeleteUser(request: AdminDeleteUserRequest): IO[AwsError, Unit]
      def adminRespondToAuthChallenge(
          request: AdminRespondToAuthChallengeRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminRespondToAuthChallengeResponse.ReadOnly
      ]
      def createGroup(request: CreateGroupRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateGroupResponse.ReadOnly
      ]
      def adminAddUserToGroup(
          request: AdminAddUserToGroupRequest
      ): IO[AwsError, Unit]
      def adminSetUserPassword(request: AdminSetUserPasswordRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserPasswordResponse.ReadOnly
      ]
      def setUserMFAPreference(request: SetUserMfaPreferenceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserMfaPreferenceResponse.ReadOnly
      ]
      def updateUserPoolDomain(request: UpdateUserPoolDomainRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolDomainResponse.ReadOnly
      ]
      def setUICustomization(request: SetUiCustomizationRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUiCustomizationResponse.ReadOnly
      ]
      def listTagsForResource(request: ListTagsForResourceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ListTagsForResourceResponse.ReadOnly
      ]
      def updateGroup(request: UpdateGroupRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateGroupResponse.ReadOnly
      ]
      def confirmDevice(request: ConfirmDeviceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmDeviceResponse.ReadOnly
      ]
      def tagResource(request: TagResourceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.TagResourceResponse.ReadOnly
      ]
      def adminDeleteUserAttributes(
          request: AdminDeleteUserAttributesRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDeleteUserAttributesResponse.ReadOnly
      ]
      def adminForgetDevice(
          request: AdminForgetDeviceRequest
      ): IO[AwsError, Unit]
      def createUserPool(request: CreateUserPoolRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolResponse.ReadOnly
      ]
      def deleteUser(request: DeleteUserRequest): IO[AwsError, Unit]
      def createUserImportJob(request: CreateUserImportJobRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserImportJobResponse.ReadOnly
      ]
      def getGroup(request: GetGroupRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetGroupResponse.ReadOnly
      ]
      def createUserPoolClient(request: CreateUserPoolClientRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolClientResponse.ReadOnly
      ]
      def updateUserPool(request: UpdateUserPoolRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolResponse.ReadOnly
      ]
      def updateDeviceStatus(request: UpdateDeviceStatusRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateDeviceStatusResponse.ReadOnly
      ]
      def describeUserPoolClient(request: DescribeUserPoolClientRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolClientResponse.ReadOnly
      ]
      def getCSVHeader(request: GetCsvHeaderRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetCsvHeaderResponse.ReadOnly
      ]
      def describeResourceServer(request: DescribeResourceServerRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeResourceServerResponse.ReadOnly
      ]
      def setUserPoolMfaConfig(request: SetUserPoolMfaConfigRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserPoolMfaConfigResponse.ReadOnly
      ]
      def describeRiskConfiguration(
          request: DescribeRiskConfigurationRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeRiskConfigurationResponse.ReadOnly
      ]
      def listUserPools(request: ListUserPoolsRequest): ZStream[
        Any,
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolDescriptionType.ReadOnly
      ]
      def adminListDevices(request: AdminListDevicesRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminListDevicesResponse.ReadOnly
      ]
      def getDevice(request: GetDeviceRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetDeviceResponse.ReadOnly
      ]
      def adminSetUserMFAPreference(
          request: AdminSetUserMfaPreferenceRequest
      ): IO[AwsError, ReadOnly]
      def updateResourceServer(request: UpdateResourceServerRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateResourceServerResponse.ReadOnly
      ]
      def verifyUserAttribute(request: VerifyUserAttributeRequest): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifyUserAttributeResponse.ReadOnly
      ]
      def getIdentityProviderByIdentifier(
          request: GetIdentityProviderByIdentifierRequest
      ): IO[
        AwsError,
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetIdentityProviderByIdentifierResponse.ReadOnly
      ]
    }
    object CognitoIdentityProviderMock extends Mock[CognitoIdentityProvider] {
      object AdminConfirmSignUp
          extends Effect[
            AdminConfirmSignUpRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminConfirmSignUpResponse.ReadOnly
          ]
      object CreateIdentityProvider
          extends Effect[
            CreateIdentityProviderRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateIdentityProviderResponse.ReadOnly
          ]
      object AdminEnableUser
          extends Effect[
            AdminEnableUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminEnableUserResponse.ReadOnly
          ]
      object RevokeToken
          extends Effect[
            RevokeTokenRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.RevokeTokenResponse.ReadOnly
          ]
      object StopUserImportJob
          extends Effect[
            StopUserImportJobRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.StopUserImportJobResponse.ReadOnly
          ]
      object AdminRemoveUserFromGroup
          extends Effect[AdminRemoveUserFromGroupRequest, AwsError, Unit]
      object DescribeUserPoolDomain
          extends Effect[
            DescribeUserPoolDomainRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolDomainResponse.ReadOnly
          ]
      object ListUsers
          extends Stream[
            ListUsersRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
          ]
      object ListUsersInGroup
          extends Stream[
            ListUsersInGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
          ]
      object GlobalSignOut
          extends Effect[
            GlobalSignOutRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GlobalSignOutResponse.ReadOnly
          ]
      object AdminGetUser
          extends Effect[
            AdminGetUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetUserResponse.ReadOnly
          ]
      object CreateUserPoolDomain
          extends Effect[
            CreateUserPoolDomainRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolDomainResponse.ReadOnly
          ]
      object AssociateSoftwareToken
          extends Effect[
            AssociateSoftwareTokenRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AssociateSoftwareTokenResponse.ReadOnly
          ]
      object AdminUpdateAuthEventFeedback
          extends Effect[
            AdminUpdateAuthEventFeedbackRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackResponse.ReadOnly
          ]
      object DescribeUserPool
          extends Effect[
            DescribeUserPoolRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolResponse.ReadOnly
          ]
      object DescribeIdentityProvider
          extends Effect[
            DescribeIdentityProviderRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeIdentityProviderResponse.ReadOnly
          ]
      object AdminUpdateDeviceStatus
          extends Effect[
            AdminUpdateDeviceStatusRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateDeviceStatusResponse.ReadOnly
          ]
      object AdminUpdateUserAttributes
          extends Effect[
            AdminUpdateUserAttributesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateUserAttributesResponse.ReadOnly
          ]
      object ResendConfirmationCode
          extends Effect[
            ResendConfirmationCodeRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ResendConfirmationCodeResponse.ReadOnly
          ]
      object SignUp
          extends Effect[
            SignUpRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.SignUpResponse.ReadOnly
          ]
      object DeleteIdentityProvider
          extends Effect[DeleteIdentityProviderRequest, AwsError, Unit]
      object GetUserAttributeVerificationCode
          extends Effect[
            GetUserAttributeVerificationCodeRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserAttributeVerificationCodeResponse.ReadOnly
          ]
      object DeleteUserPoolClient
          extends Effect[DeleteUserPoolClientRequest, AwsError, Unit]
      object DeleteGroup extends Effect[DeleteGroupRequest, AwsError, Unit]
      object AdminSetUserSettings
          extends Effect[
            AdminSetUserSettingsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserSettingsResponse.ReadOnly
          ]
      object GetSigningCertificate
          extends Effect[
            GetSigningCertificateRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetSigningCertificateResponse.ReadOnly
          ]
      object GetUserPoolMfaConfig
          extends Effect[
            GetUserPoolMfaConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserPoolMfaConfigResponse.ReadOnly
          ]
      object UpdateUserPoolClient
          extends Effect[
            UpdateUserPoolClientRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolClientResponse.ReadOnly
          ]
      object InitiateAuth
          extends Effect[
            InitiateAuthRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.InitiateAuthResponse.ReadOnly
          ]
      object ChangePassword
          extends Effect[
            ChangePasswordRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ChangePasswordResponse.ReadOnly
          ]
      object AdminListGroupsForUser
          extends Stream[
            AdminListGroupsForUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
          ]
      object DeleteUserAttributes
          extends Effect[
            DeleteUserAttributesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserAttributesResponse.ReadOnly
          ]
      object AdminResetUserPassword
          extends Effect[
            AdminResetUserPasswordRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminResetUserPasswordResponse.ReadOnly
          ]
      object AddCustomAttributes
          extends Effect[
            AddCustomAttributesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AddCustomAttributesResponse.ReadOnly
          ]
      object AdminUserGlobalSignOut
          extends Effect[
            AdminUserGlobalSignOutRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUserGlobalSignOutResponse.ReadOnly
          ]
      object GetUICustomization
          extends Effect[
            GetUiCustomizationRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUiCustomizationResponse.ReadOnly
          ]
      object CreateResourceServer
          extends Effect[
            CreateResourceServerRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateResourceServerResponse.ReadOnly
          ]
      object AdminDisableUser
          extends Effect[
            AdminDisableUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableUserResponse.ReadOnly
          ]
      object RespondToAuthChallenge
          extends Effect[
            RespondToAuthChallengeRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.RespondToAuthChallengeResponse.ReadOnly
          ]
      object GetUser
          extends Effect[
            GetUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserResponse.ReadOnly
          ]
      object DeleteResourceServer
          extends Effect[DeleteResourceServerRequest, AwsError, Unit]
      object ListGroups
          extends Stream[
            ListGroupsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
          ]
      object ListDevices
          extends Effect[
            ListDevicesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ListDevicesResponse.ReadOnly
          ]
      object VerifySoftwareToken
          extends Effect[
            VerifySoftwareTokenRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifySoftwareTokenResponse.ReadOnly
          ]
      object AdminDisableProviderForUser
          extends Effect[
            AdminDisableProviderForUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableProviderForUserResponse.ReadOnly
          ]
      object ForgotPassword
          extends Effect[
            ForgotPasswordRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ForgotPasswordResponse.ReadOnly
          ]
      object UpdateAuthEventFeedback
          extends Effect[
            UpdateAuthEventFeedbackRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateAuthEventFeedbackResponse.ReadOnly
          ]
      object UpdateIdentityProvider
          extends Effect[
            UpdateIdentityProviderRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateIdentityProviderResponse.ReadOnly
          ]
      object ListUserPoolClients
          extends Stream[
            ListUserPoolClientsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolClientDescription.ReadOnly
          ]
      object StartUserImportJob
          extends Effect[
            StartUserImportJobRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.StartUserImportJobResponse.ReadOnly
          ]
      object UpdateUserAttributes
          extends Effect[
            UpdateUserAttributesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserAttributesResponse.ReadOnly
          ]
      object AdminListUserAuthEvents
          extends Stream[
            AdminListUserAuthEventsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AuthEventType.ReadOnly
          ]
      object ListIdentityProviders
          extends Stream[
            ListIdentityProvidersRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ProviderDescription.ReadOnly
          ]
      object ListUserImportJobs
          extends Effect[
            ListUserImportJobsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ListUserImportJobsResponse.ReadOnly
          ]
      object AdminCreateUser
          extends Effect[
            AdminCreateUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminCreateUserResponse.ReadOnly
          ]
      object AdminInitiateAuth
          extends Effect[
            AdminInitiateAuthRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminInitiateAuthResponse.ReadOnly
          ]
      object ConfirmSignUp
          extends Effect[
            ConfirmSignUpRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmSignUpResponse.ReadOnly
          ]
      object AdminGetDevice
          extends Effect[
            AdminGetDeviceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetDeviceResponse.ReadOnly
          ]
      object AdminLinkProviderForUser
          extends Effect[
            AdminLinkProviderForUserRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminLinkProviderForUserResponse.ReadOnly
          ]
      object ConfirmForgotPassword
          extends Effect[
            ConfirmForgotPasswordRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmForgotPasswordResponse.ReadOnly
          ]
      object SetRiskConfiguration
          extends Effect[
            SetRiskConfigurationRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.SetRiskConfigurationResponse.ReadOnly
          ]
      object ForgetDevice extends Effect[ForgetDeviceRequest, AwsError, Unit]
      object DeleteUserPool
          extends Effect[DeleteUserPoolRequest, AwsError, Unit]
      object UntagResource
          extends Effect[
            UntagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UntagResourceResponse.ReadOnly
          ]
      object ListResourceServers
          extends Stream[
            ListResourceServersRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ResourceServerType.ReadOnly
          ]
      object DescribeUserImportJob
          extends Effect[
            DescribeUserImportJobRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserImportJobResponse.ReadOnly
          ]
      object DeleteUserPoolDomain
          extends Effect[
            DeleteUserPoolDomainRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserPoolDomainResponse.ReadOnly
          ]
      object SetUserSettings
          extends Effect[
            SetUserSettingsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserSettingsResponse.ReadOnly
          ]
      object AdminDeleteUser
          extends Effect[AdminDeleteUserRequest, AwsError, Unit]
      object AdminRespondToAuthChallenge
          extends Effect[
            AdminRespondToAuthChallengeRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminRespondToAuthChallengeResponse.ReadOnly
          ]
      object CreateGroup
          extends Effect[
            CreateGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateGroupResponse.ReadOnly
          ]
      object AdminAddUserToGroup
          extends Effect[AdminAddUserToGroupRequest, AwsError, Unit]
      object AdminSetUserPassword
          extends Effect[
            AdminSetUserPasswordRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserPasswordResponse.ReadOnly
          ]
      object SetUserMFAPreference
          extends Effect[
            SetUserMfaPreferenceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserMfaPreferenceResponse.ReadOnly
          ]
      object UpdateUserPoolDomain
          extends Effect[
            UpdateUserPoolDomainRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolDomainResponse.ReadOnly
          ]
      object SetUICustomization
          extends Effect[
            SetUiCustomizationRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUiCustomizationResponse.ReadOnly
          ]
      object ListTagsForResource
          extends Effect[
            ListTagsForResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ListTagsForResourceResponse.ReadOnly
          ]
      object UpdateGroup
          extends Effect[
            UpdateGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateGroupResponse.ReadOnly
          ]
      object ConfirmDevice
          extends Effect[
            ConfirmDeviceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmDeviceResponse.ReadOnly
          ]
      object TagResource
          extends Effect[
            TagResourceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.TagResourceResponse.ReadOnly
          ]
      object AdminDeleteUserAttributes
          extends Effect[
            AdminDeleteUserAttributesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDeleteUserAttributesResponse.ReadOnly
          ]
      object AdminForgetDevice
          extends Effect[AdminForgetDeviceRequest, AwsError, Unit]
      object CreateUserPool
          extends Effect[
            CreateUserPoolRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolResponse.ReadOnly
          ]
      object DeleteUser extends Effect[DeleteUserRequest, AwsError, Unit]
      object CreateUserImportJob
          extends Effect[
            CreateUserImportJobRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserImportJobResponse.ReadOnly
          ]
      object GetGroup
          extends Effect[
            GetGroupRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetGroupResponse.ReadOnly
          ]
      object CreateUserPoolClient
          extends Effect[
            CreateUserPoolClientRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolClientResponse.ReadOnly
          ]
      object UpdateUserPool
          extends Effect[
            UpdateUserPoolRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolResponse.ReadOnly
          ]
      object UpdateDeviceStatus
          extends Effect[
            UpdateDeviceStatusRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateDeviceStatusResponse.ReadOnly
          ]
      object DescribeUserPoolClient
          extends Effect[
            DescribeUserPoolClientRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolClientResponse.ReadOnly
          ]
      object GetCSVHeader
          extends Effect[
            GetCsvHeaderRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetCsvHeaderResponse.ReadOnly
          ]
      object DescribeResourceServer
          extends Effect[
            DescribeResourceServerRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeResourceServerResponse.ReadOnly
          ]
      object SetUserPoolMfaConfig
          extends Effect[
            SetUserPoolMfaConfigRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserPoolMfaConfigResponse.ReadOnly
          ]
      object DescribeRiskConfiguration
          extends Effect[
            DescribeRiskConfigurationRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeRiskConfigurationResponse.ReadOnly
          ]
      object ListUserPools
          extends Stream[
            ListUserPoolsRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolDescriptionType.ReadOnly
          ]
      object AdminListDevices
          extends Effect[
            AdminListDevicesRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminListDevicesResponse.ReadOnly
          ]
      object GetDevice
          extends Effect[
            GetDeviceRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetDeviceResponse.ReadOnly
          ]
      object AdminSetUserMFAPreference
          extends Effect[AdminSetUserMfaPreferenceRequest, AwsError, ReadOnly]
      object UpdateResourceServer
          extends Effect[
            UpdateResourceServerRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateResourceServerResponse.ReadOnly
          ]
      object VerifyUserAttribute
          extends Effect[
            VerifyUserAttributeRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifyUserAttributeResponse.ReadOnly
          ]
      object GetIdentityProviderByIdentifier
          extends Effect[
            GetIdentityProviderByIdentifierRequest,
            AwsError,
            io.github.vigoo.zioaws.cognitoidentityprovider.model.GetIdentityProviderByIdentifierResponse.ReadOnly
          ]
      val compose: URLayer[Has[Proxy], CognitoIdentityProvider] =
        ZLayer.fromServiceM { proxy =>
          withRuntime.map { rts =>
            new CognitoIdentityProvider.Service {
              val api: CognitoIdentityProviderAsyncClient = null
              def withAspect[R1](
                  newAspect: AwsCallAspect[R1],
                  r: R1
              ): CognitoIdentityProvider.Service = this
              def adminConfirmSignUp(request: AdminConfirmSignUpRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminConfirmSignUpResponse.ReadOnly
              ] = proxy(AdminConfirmSignUp, request)
              def createIdentityProvider(
                  request: CreateIdentityProviderRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateIdentityProviderResponse.ReadOnly
              ] = proxy(CreateIdentityProvider, request)
              def adminEnableUser(request: AdminEnableUserRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminEnableUserResponse.ReadOnly
              ] = proxy(AdminEnableUser, request)
              def revokeToken(request: RevokeTokenRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.RevokeTokenResponse.ReadOnly
              ] = proxy(RevokeToken, request)
              def stopUserImportJob(request: StopUserImportJobRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.StopUserImportJobResponse.ReadOnly
              ] = proxy(StopUserImportJob, request)
              def adminRemoveUserFromGroup(
                  request: AdminRemoveUserFromGroupRequest
              ): IO[AwsError, Unit] = proxy(AdminRemoveUserFromGroup, request)
              def describeUserPoolDomain(
                  request: DescribeUserPoolDomainRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolDomainResponse.ReadOnly
              ] = proxy(DescribeUserPoolDomain, request)
              def listUsers(request: ListUsersRequest): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
              ] = rts.unsafeRun(proxy(ListUsers, request))
              def listUsersInGroup(request: ListUsersInGroupRequest): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
              ] = rts.unsafeRun(proxy(ListUsersInGroup, request))
              def globalSignOut(request: GlobalSignOutRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GlobalSignOutResponse.ReadOnly
              ] = proxy(GlobalSignOut, request)
              def adminGetUser(request: AdminGetUserRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetUserResponse.ReadOnly
              ] = proxy(AdminGetUser, request)
              def createUserPoolDomain(
                  request: CreateUserPoolDomainRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolDomainResponse.ReadOnly
              ] = proxy(CreateUserPoolDomain, request)
              def associateSoftwareToken(
                  request: AssociateSoftwareTokenRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AssociateSoftwareTokenResponse.ReadOnly
              ] = proxy(AssociateSoftwareToken, request)
              def adminUpdateAuthEventFeedback(
                  request: AdminUpdateAuthEventFeedbackRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackResponse.ReadOnly
              ] = proxy(AdminUpdateAuthEventFeedback, request)
              def describeUserPool(request: DescribeUserPoolRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolResponse.ReadOnly
              ] = proxy(DescribeUserPool, request)
              def describeIdentityProvider(
                  request: DescribeIdentityProviderRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeIdentityProviderResponse.ReadOnly
              ] = proxy(DescribeIdentityProvider, request)
              def adminUpdateDeviceStatus(
                  request: AdminUpdateDeviceStatusRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateDeviceStatusResponse.ReadOnly
              ] = proxy(AdminUpdateDeviceStatus, request)
              def adminUpdateUserAttributes(
                  request: AdminUpdateUserAttributesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateUserAttributesResponse.ReadOnly
              ] = proxy(AdminUpdateUserAttributes, request)
              def resendConfirmationCode(
                  request: ResendConfirmationCodeRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ResendConfirmationCodeResponse.ReadOnly
              ] = proxy(ResendConfirmationCode, request)
              def signUp(request: SignUpRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.SignUpResponse.ReadOnly
              ] = proxy(SignUp, request)
              def deleteIdentityProvider(
                  request: DeleteIdentityProviderRequest
              ): IO[AwsError, Unit] = proxy(DeleteIdentityProvider, request)
              def getUserAttributeVerificationCode(
                  request: GetUserAttributeVerificationCodeRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserAttributeVerificationCodeResponse.ReadOnly
              ] = proxy(GetUserAttributeVerificationCode, request)
              def deleteUserPoolClient(
                  request: DeleteUserPoolClientRequest
              ): IO[AwsError, Unit] = proxy(DeleteUserPoolClient, request)
              def deleteGroup(request: DeleteGroupRequest): IO[AwsError, Unit] =
                proxy(DeleteGroup, request)
              def adminSetUserSettings(
                  request: AdminSetUserSettingsRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserSettingsResponse.ReadOnly
              ] = proxy(AdminSetUserSettings, request)
              def getSigningCertificate(
                  request: GetSigningCertificateRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetSigningCertificateResponse.ReadOnly
              ] = proxy(GetSigningCertificate, request)
              def getUserPoolMfaConfig(
                  request: GetUserPoolMfaConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserPoolMfaConfigResponse.ReadOnly
              ] = proxy(GetUserPoolMfaConfig, request)
              def updateUserPoolClient(
                  request: UpdateUserPoolClientRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolClientResponse.ReadOnly
              ] = proxy(UpdateUserPoolClient, request)
              def initiateAuth(request: InitiateAuthRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.InitiateAuthResponse.ReadOnly
              ] = proxy(InitiateAuth, request)
              def changePassword(request: ChangePasswordRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ChangePasswordResponse.ReadOnly
              ] = proxy(ChangePassword, request)
              def adminListGroupsForUser(
                  request: AdminListGroupsForUserRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
              ] = rts.unsafeRun(proxy(AdminListGroupsForUser, request))
              def deleteUserAttributes(
                  request: DeleteUserAttributesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserAttributesResponse.ReadOnly
              ] = proxy(DeleteUserAttributes, request)
              def adminResetUserPassword(
                  request: AdminResetUserPasswordRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminResetUserPasswordResponse.ReadOnly
              ] = proxy(AdminResetUserPassword, request)
              def addCustomAttributes(request: AddCustomAttributesRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AddCustomAttributesResponse.ReadOnly
              ] = proxy(AddCustomAttributes, request)
              def adminUserGlobalSignOut(
                  request: AdminUserGlobalSignOutRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUserGlobalSignOutResponse.ReadOnly
              ] = proxy(AdminUserGlobalSignOut, request)
              def getUICustomization(request: GetUiCustomizationRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUiCustomizationResponse.ReadOnly
              ] = proxy(GetUICustomization, request)
              def createResourceServer(
                  request: CreateResourceServerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateResourceServerResponse.ReadOnly
              ] = proxy(CreateResourceServer, request)
              def adminDisableUser(request: AdminDisableUserRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableUserResponse.ReadOnly
              ] = proxy(AdminDisableUser, request)
              def respondToAuthChallenge(
                  request: RespondToAuthChallengeRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.RespondToAuthChallengeResponse.ReadOnly
              ] = proxy(RespondToAuthChallenge, request)
              def getUser(request: GetUserRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserResponse.ReadOnly
              ] = proxy(GetUser, request)
              def deleteResourceServer(
                  request: DeleteResourceServerRequest
              ): IO[AwsError, Unit] = proxy(DeleteResourceServer, request)
              def listGroups(request: ListGroupsRequest): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
              ] = rts.unsafeRun(proxy(ListGroups, request))
              def listDevices(request: ListDevicesRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ListDevicesResponse.ReadOnly
              ] = proxy(ListDevices, request)
              def verifySoftwareToken(request: VerifySoftwareTokenRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifySoftwareTokenResponse.ReadOnly
              ] = proxy(VerifySoftwareToken, request)
              def adminDisableProviderForUser(
                  request: AdminDisableProviderForUserRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableProviderForUserResponse.ReadOnly
              ] = proxy(AdminDisableProviderForUser, request)
              def forgotPassword(request: ForgotPasswordRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ForgotPasswordResponse.ReadOnly
              ] = proxy(ForgotPassword, request)
              def updateAuthEventFeedback(
                  request: UpdateAuthEventFeedbackRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateAuthEventFeedbackResponse.ReadOnly
              ] = proxy(UpdateAuthEventFeedback, request)
              def updateIdentityProvider(
                  request: UpdateIdentityProviderRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateIdentityProviderResponse.ReadOnly
              ] = proxy(UpdateIdentityProvider, request)
              def listUserPoolClients(
                  request: ListUserPoolClientsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolClientDescription.ReadOnly
              ] = rts.unsafeRun(proxy(ListUserPoolClients, request))
              def startUserImportJob(request: StartUserImportJobRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.StartUserImportJobResponse.ReadOnly
              ] = proxy(StartUserImportJob, request)
              def updateUserAttributes(
                  request: UpdateUserAttributesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserAttributesResponse.ReadOnly
              ] = proxy(UpdateUserAttributes, request)
              def adminListUserAuthEvents(
                  request: AdminListUserAuthEventsRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AuthEventType.ReadOnly
              ] = rts.unsafeRun(proxy(AdminListUserAuthEvents, request))
              def listIdentityProviders(
                  request: ListIdentityProvidersRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ProviderDescription.ReadOnly
              ] = rts.unsafeRun(proxy(ListIdentityProviders, request))
              def listUserImportJobs(request: ListUserImportJobsRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ListUserImportJobsResponse.ReadOnly
              ] = proxy(ListUserImportJobs, request)
              def adminCreateUser(request: AdminCreateUserRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminCreateUserResponse.ReadOnly
              ] = proxy(AdminCreateUser, request)
              def adminInitiateAuth(request: AdminInitiateAuthRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminInitiateAuthResponse.ReadOnly
              ] = proxy(AdminInitiateAuth, request)
              def confirmSignUp(request: ConfirmSignUpRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmSignUpResponse.ReadOnly
              ] = proxy(ConfirmSignUp, request)
              def adminGetDevice(request: AdminGetDeviceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetDeviceResponse.ReadOnly
              ] = proxy(AdminGetDevice, request)
              def adminLinkProviderForUser(
                  request: AdminLinkProviderForUserRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminLinkProviderForUserResponse.ReadOnly
              ] = proxy(AdminLinkProviderForUser, request)
              def confirmForgotPassword(
                  request: ConfirmForgotPasswordRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmForgotPasswordResponse.ReadOnly
              ] = proxy(ConfirmForgotPassword, request)
              def setRiskConfiguration(
                  request: SetRiskConfigurationRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.SetRiskConfigurationResponse.ReadOnly
              ] = proxy(SetRiskConfiguration, request)
              def forgetDevice(
                  request: ForgetDeviceRequest
              ): IO[AwsError, Unit] = proxy(ForgetDevice, request)
              def deleteUserPool(
                  request: DeleteUserPoolRequest
              ): IO[AwsError, Unit] = proxy(DeleteUserPool, request)
              def untagResource(request: UntagResourceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UntagResourceResponse.ReadOnly
              ] = proxy(UntagResource, request)
              def listResourceServers(
                  request: ListResourceServersRequest
              ): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ResourceServerType.ReadOnly
              ] = rts.unsafeRun(proxy(ListResourceServers, request))
              def describeUserImportJob(
                  request: DescribeUserImportJobRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserImportJobResponse.ReadOnly
              ] = proxy(DescribeUserImportJob, request)
              def deleteUserPoolDomain(
                  request: DeleteUserPoolDomainRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserPoolDomainResponse.ReadOnly
              ] = proxy(DeleteUserPoolDomain, request)
              def setUserSettings(request: SetUserSettingsRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserSettingsResponse.ReadOnly
              ] = proxy(SetUserSettings, request)
              def adminDeleteUser(
                  request: AdminDeleteUserRequest
              ): IO[AwsError, Unit] = proxy(AdminDeleteUser, request)
              def adminRespondToAuthChallenge(
                  request: AdminRespondToAuthChallengeRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminRespondToAuthChallengeResponse.ReadOnly
              ] = proxy(AdminRespondToAuthChallenge, request)
              def createGroup(request: CreateGroupRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateGroupResponse.ReadOnly
              ] = proxy(CreateGroup, request)
              def adminAddUserToGroup(
                  request: AdminAddUserToGroupRequest
              ): IO[AwsError, Unit] = proxy(AdminAddUserToGroup, request)
              def adminSetUserPassword(
                  request: AdminSetUserPasswordRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserPasswordResponse.ReadOnly
              ] = proxy(AdminSetUserPassword, request)
              def setUserMFAPreference(
                  request: SetUserMfaPreferenceRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserMfaPreferenceResponse.ReadOnly
              ] = proxy(SetUserMFAPreference, request)
              def updateUserPoolDomain(
                  request: UpdateUserPoolDomainRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolDomainResponse.ReadOnly
              ] = proxy(UpdateUserPoolDomain, request)
              def setUICustomization(request: SetUiCustomizationRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUiCustomizationResponse.ReadOnly
              ] = proxy(SetUICustomization, request)
              def listTagsForResource(request: ListTagsForResourceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ListTagsForResourceResponse.ReadOnly
              ] = proxy(ListTagsForResource, request)
              def updateGroup(request: UpdateGroupRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateGroupResponse.ReadOnly
              ] = proxy(UpdateGroup, request)
              def confirmDevice(request: ConfirmDeviceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmDeviceResponse.ReadOnly
              ] = proxy(ConfirmDevice, request)
              def tagResource(request: TagResourceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.TagResourceResponse.ReadOnly
              ] = proxy(TagResource, request)
              def adminDeleteUserAttributes(
                  request: AdminDeleteUserAttributesRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDeleteUserAttributesResponse.ReadOnly
              ] = proxy(AdminDeleteUserAttributes, request)
              def adminForgetDevice(
                  request: AdminForgetDeviceRequest
              ): IO[AwsError, Unit] = proxy(AdminForgetDevice, request)
              def createUserPool(request: CreateUserPoolRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolResponse.ReadOnly
              ] = proxy(CreateUserPool, request)
              def deleteUser(request: DeleteUserRequest): IO[AwsError, Unit] =
                proxy(DeleteUser, request)
              def createUserImportJob(request: CreateUserImportJobRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserImportJobResponse.ReadOnly
              ] = proxy(CreateUserImportJob, request)
              def getGroup(request: GetGroupRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetGroupResponse.ReadOnly
              ] = proxy(GetGroup, request)
              def createUserPoolClient(
                  request: CreateUserPoolClientRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolClientResponse.ReadOnly
              ] = proxy(CreateUserPoolClient, request)
              def updateUserPool(request: UpdateUserPoolRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolResponse.ReadOnly
              ] = proxy(UpdateUserPool, request)
              def updateDeviceStatus(request: UpdateDeviceStatusRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateDeviceStatusResponse.ReadOnly
              ] = proxy(UpdateDeviceStatus, request)
              def describeUserPoolClient(
                  request: DescribeUserPoolClientRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolClientResponse.ReadOnly
              ] = proxy(DescribeUserPoolClient, request)
              def getCSVHeader(request: GetCsvHeaderRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetCsvHeaderResponse.ReadOnly
              ] = proxy(GetCSVHeader, request)
              def describeResourceServer(
                  request: DescribeResourceServerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeResourceServerResponse.ReadOnly
              ] = proxy(DescribeResourceServer, request)
              def setUserPoolMfaConfig(
                  request: SetUserPoolMfaConfigRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserPoolMfaConfigResponse.ReadOnly
              ] = proxy(SetUserPoolMfaConfig, request)
              def describeRiskConfiguration(
                  request: DescribeRiskConfigurationRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeRiskConfigurationResponse.ReadOnly
              ] = proxy(DescribeRiskConfiguration, request)
              def listUserPools(request: ListUserPoolsRequest): ZStream[
                Any,
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolDescriptionType.ReadOnly
              ] = rts.unsafeRun(proxy(ListUserPools, request))
              def adminListDevices(request: AdminListDevicesRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminListDevicesResponse.ReadOnly
              ] = proxy(AdminListDevices, request)
              def getDevice(request: GetDeviceRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetDeviceResponse.ReadOnly
              ] = proxy(GetDevice, request)
              def adminSetUserMFAPreference(
                  request: AdminSetUserMfaPreferenceRequest
              ): IO[AwsError, ReadOnly] =
                proxy(AdminSetUserMFAPreference, request)
              def updateResourceServer(
                  request: UpdateResourceServerRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateResourceServerResponse.ReadOnly
              ] = proxy(UpdateResourceServer, request)
              def verifyUserAttribute(request: VerifyUserAttributeRequest): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifyUserAttributeResponse.ReadOnly
              ] = proxy(VerifyUserAttribute, request)
              def getIdentityProviderByIdentifier(
                  request: GetIdentityProviderByIdentifierRequest
              ): IO[
                AwsError,
                io.github.vigoo.zioaws.cognitoidentityprovider.model.GetIdentityProviderByIdentifierResponse.ReadOnly
              ] = proxy(GetIdentityProviderByIdentifier, request)
            }
          }
        }
    }
  }
  val live: ZLayer[AwsConfig, java.lang.Throwable, CognitoIdentityProvider] =
    customized(identity)
  def customized(
      customization: CognitoIdentityProviderAsyncClientBuilder => CognitoIdentityProviderAsyncClientBuilder
  ): ZLayer[AwsConfig, java.lang.Throwable, CognitoIdentityProvider] = managed(
    customization
  ).toLayer
  def managed(
      customization: CognitoIdentityProviderAsyncClientBuilder => CognitoIdentityProviderAsyncClientBuilder
  ): ZManaged[AwsConfig, java.lang.Throwable, CognitoIdentityProvider.Service] =
    for (
      awsConfig <- ZManaged.service[AwsConfig.Service];
      executor <- ZIO.executor.toManaged_;
      builder = CognitoIdentityProviderAsyncClient
        .builder()
        .asyncConfiguration(
          software.amazon.awssdk.core.client.config.ClientAsyncConfiguration
            .builder()
            .advancedOption(
              software.amazon.awssdk.core.client.config.SdkAdvancedAsyncClientOption.FUTURE_COMPLETION_EXECUTOR,
              executor.asJava
            )
            .build()
        );
      b0 <- awsConfig
        .configure[
          CognitoIdentityProviderAsyncClient,
          CognitoIdentityProviderAsyncClientBuilder
        ](builder)
        .toManaged_;
      b1 <- awsConfig
        .configureHttpClient[
          CognitoIdentityProviderAsyncClient,
          CognitoIdentityProviderAsyncClientBuilder
        ](
          b0,
          io.github.vigoo.zioaws.core.httpclient
            .ServiceHttpCapabilities(supportsHttp2 = false)
        )
        .toManaged_; client <- zio.ZIO(customization(b1).build()).toManaged_
    )
      yield new CognitoIdentityProviderImpl(
        client,
        AwsCallAspect.identity,
        ().asInstanceOf[Any]
      )
  private class CognitoIdentityProviderImpl[R](
      override val api: CognitoIdentityProviderAsyncClient,
      override val aspect: AwsCallAspect[R],
      r: R
  ) extends CognitoIdentityProvider.Service
      with AwsServiceBase[R, CognitoIdentityProviderImpl] {
    override val serviceName: String = "CognitoIdentityProvider"
    override def withAspect[R1](
        newAspect: AwsCallAspect[R1],
        r: R1
    ): CognitoIdentityProviderImpl[R1] =
      new CognitoIdentityProviderImpl(api, newAspect, r)
    def adminConfirmSignUp(request: AdminConfirmSignUpRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminConfirmSignUpResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminConfirmSignUpRequest,
      AdminConfirmSignUpResponse
    ]("adminConfirmSignUp", api.adminConfirmSignUp)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminConfirmSignUpResponse.wrap
      )
      .provide(r)
    def createIdentityProvider(request: CreateIdentityProviderRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateIdentityProviderResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateIdentityProviderRequest,
      CreateIdentityProviderResponse
    ]("createIdentityProvider", api.createIdentityProvider)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateIdentityProviderResponse.wrap
    ).provide(r)
    def adminEnableUser(request: AdminEnableUserRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminEnableUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminEnableUserRequest,
      AdminEnableUserResponse
    ]("adminEnableUser", api.adminEnableUser)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminEnableUserResponse.wrap
      )
      .provide(r)
    def revokeToken(request: RevokeTokenRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.RevokeTokenResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.RevokeTokenRequest,
      RevokeTokenResponse
    ]("revokeToken", api.revokeToken)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.RevokeTokenResponse.wrap
      )
      .provide(r)
    def stopUserImportJob(request: StopUserImportJobRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.StopUserImportJobResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.StopUserImportJobRequest,
      StopUserImportJobResponse
    ]("stopUserImportJob", api.stopUserImportJob)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.StopUserImportJobResponse.wrap
      )
      .provide(r)
    def adminRemoveUserFromGroup(
        request: AdminRemoveUserFromGroupRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminRemoveUserFromGroupRequest,
      AdminRemoveUserFromGroupResponse
    ]("adminRemoveUserFromGroup", api.adminRemoveUserFromGroup)(
      request.buildAwsValue()
    ).unit.provide(r)
    def describeUserPoolDomain(request: DescribeUserPoolDomainRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolDomainResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeUserPoolDomainRequest,
      DescribeUserPoolDomainResponse
    ]("describeUserPoolDomain", api.describeUserPoolDomain)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolDomainResponse.wrap
    ).provide(r)
    def listUsers(request: ListUsersRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
    ] = asyncJavaPaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListUsersRequest,
      UserType,
      ListUsersPublisher
    ]("listUsers", api.listUsersPaginator, _.users())(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.wrap(item)
      )
      .provide(r)
    def listUsersInGroup(request: ListUsersInGroupRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListUsersInGroupRequest,
      ListUsersInGroupResponse,
      UserType
    ](
      "listUsersInGroup",
      api.listUsersInGroup,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.users().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.wrap(item)
      )
      .provide(r)
    def globalSignOut(request: GlobalSignOutRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GlobalSignOutResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GlobalSignOutRequest,
      GlobalSignOutResponse
    ]("globalSignOut", api.globalSignOut)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GlobalSignOutResponse.wrap
      )
      .provide(r)
    def adminGetUser(request: AdminGetUserRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminGetUserRequest,
      AdminGetUserResponse
    ]("adminGetUser", api.adminGetUser)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetUserResponse.wrap
      )
      .provide(r)
    def createUserPoolDomain(request: CreateUserPoolDomainRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolDomainResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolDomainRequest,
      CreateUserPoolDomainResponse
    ]("createUserPoolDomain", api.createUserPoolDomain)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolDomainResponse.wrap
      )
      .provide(r)
    def associateSoftwareToken(request: AssociateSoftwareTokenRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AssociateSoftwareTokenResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AssociateSoftwareTokenRequest,
      AssociateSoftwareTokenResponse
    ]("associateSoftwareToken", api.associateSoftwareToken)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AssociateSoftwareTokenResponse.wrap
    ).provide(r)
    def adminUpdateAuthEventFeedback(
        request: AdminUpdateAuthEventFeedbackRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackRequest,
      AdminUpdateAuthEventFeedbackResponse
    ]("adminUpdateAuthEventFeedback", api.adminUpdateAuthEventFeedback)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackResponse.wrap
    ).provide(r)
    def describeUserPool(request: DescribeUserPoolRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeUserPoolRequest,
      DescribeUserPoolResponse
    ]("describeUserPool", api.describeUserPool)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolResponse.wrap
      )
      .provide(r)
    def describeIdentityProvider(request: DescribeIdentityProviderRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeIdentityProviderResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeIdentityProviderRequest,
      DescribeIdentityProviderResponse
    ]("describeIdentityProvider", api.describeIdentityProvider)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeIdentityProviderResponse.wrap
    ).provide(r)
    def adminUpdateDeviceStatus(request: AdminUpdateDeviceStatusRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateDeviceStatusResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminUpdateDeviceStatusRequest,
      AdminUpdateDeviceStatusResponse
    ]("adminUpdateDeviceStatus", api.adminUpdateDeviceStatus)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateDeviceStatusResponse.wrap
    ).provide(r)
    def adminUpdateUserAttributes(
        request: AdminUpdateUserAttributesRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateUserAttributesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminUpdateUserAttributesRequest,
      AdminUpdateUserAttributesResponse
    ]("adminUpdateUserAttributes", api.adminUpdateUserAttributes)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateUserAttributesResponse.wrap
    ).provide(r)
    def resendConfirmationCode(request: ResendConfirmationCodeRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ResendConfirmationCodeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ResendConfirmationCodeRequest,
      ResendConfirmationCodeResponse
    ]("resendConfirmationCode", api.resendConfirmationCode)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ResendConfirmationCodeResponse.wrap
    ).provide(r)
    def signUp(request: SignUpRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.SignUpResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.SignUpRequest,
      SignUpResponse
    ]("signUp", api.signUp)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SignUpResponse.wrap
      )
      .provide(r)
    def deleteIdentityProvider(
        request: DeleteIdentityProviderRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteIdentityProviderRequest,
      DeleteIdentityProviderResponse
    ]("deleteIdentityProvider", api.deleteIdentityProvider)(
      request.buildAwsValue()
    ).unit.provide(r)
    def getUserAttributeVerificationCode(
        request: GetUserAttributeVerificationCodeRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserAttributeVerificationCodeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetUserAttributeVerificationCodeRequest,
      GetUserAttributeVerificationCodeResponse
    ]("getUserAttributeVerificationCode", api.getUserAttributeVerificationCode)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserAttributeVerificationCodeResponse.wrap
    ).provide(r)
    def deleteUserPoolClient(
        request: DeleteUserPoolClientRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteUserPoolClientRequest,
      DeleteUserPoolClientResponse
    ]("deleteUserPoolClient", api.deleteUserPoolClient)(
      request.buildAwsValue()
    ).unit.provide(r)
    def deleteGroup(request: DeleteGroupRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteGroupRequest,
        DeleteGroupResponse
      ]("deleteGroup", api.deleteGroup)(request.buildAwsValue()).unit.provide(r)
    def adminSetUserSettings(request: AdminSetUserSettingsRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserSettingsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminSetUserSettingsRequest,
      AdminSetUserSettingsResponse
    ]("adminSetUserSettings", api.adminSetUserSettings)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserSettingsResponse.wrap
      )
      .provide(r)
    def getSigningCertificate(request: GetSigningCertificateRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetSigningCertificateResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetSigningCertificateRequest,
      GetSigningCertificateResponse
    ]("getSigningCertificate", api.getSigningCertificate)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetSigningCertificateResponse.wrap
    ).provide(r)
    def getUserPoolMfaConfig(request: GetUserPoolMfaConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserPoolMfaConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetUserPoolMfaConfigRequest,
      GetUserPoolMfaConfigResponse
    ]("getUserPoolMfaConfig", api.getUserPoolMfaConfig)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserPoolMfaConfigResponse.wrap
      )
      .provide(r)
    def updateUserPoolClient(request: UpdateUserPoolClientRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolClientResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateUserPoolClientRequest,
      UpdateUserPoolClientResponse
    ]("updateUserPoolClient", api.updateUserPoolClient)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolClientResponse.wrap
      )
      .provide(r)
    def initiateAuth(request: InitiateAuthRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.InitiateAuthResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.InitiateAuthRequest,
      InitiateAuthResponse
    ]("initiateAuth", api.initiateAuth)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.InitiateAuthResponse.wrap
      )
      .provide(r)
    def changePassword(request: ChangePasswordRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ChangePasswordResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ChangePasswordRequest,
      ChangePasswordResponse
    ]("changePassword", api.changePassword)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ChangePasswordResponse.wrap
      )
      .provide(r)
    def adminListGroupsForUser(request: AdminListGroupsForUserRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminListGroupsForUserRequest,
      AdminListGroupsForUserResponse,
      GroupType
    ](
      "adminListGroupsForUser",
      api.adminListGroupsForUser,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.groups().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType
          .wrap(item)
      )
      .provide(r)
    def deleteUserAttributes(request: DeleteUserAttributesRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserAttributesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteUserAttributesRequest,
      DeleteUserAttributesResponse
    ]("deleteUserAttributes", api.deleteUserAttributes)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserAttributesResponse.wrap
      )
      .provide(r)
    def adminResetUserPassword(request: AdminResetUserPasswordRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminResetUserPasswordResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminResetUserPasswordRequest,
      AdminResetUserPasswordResponse
    ]("adminResetUserPassword", api.adminResetUserPassword)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminResetUserPasswordResponse.wrap
    ).provide(r)
    def addCustomAttributes(request: AddCustomAttributesRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AddCustomAttributesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AddCustomAttributesRequest,
      AddCustomAttributesResponse
    ]("addCustomAttributes", api.addCustomAttributes)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AddCustomAttributesResponse.wrap
      )
      .provide(r)
    def adminUserGlobalSignOut(request: AdminUserGlobalSignOutRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUserGlobalSignOutResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminUserGlobalSignOutRequest,
      AdminUserGlobalSignOutResponse
    ]("adminUserGlobalSignOut", api.adminUserGlobalSignOut)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUserGlobalSignOutResponse.wrap
    ).provide(r)
    def getUICustomization(request: GetUiCustomizationRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUiCustomizationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetUiCustomizationRequest,
      GetUiCustomizationResponse
    ]("getUICustomization", api.getUICustomization)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUiCustomizationResponse.wrap
      )
      .provide(r)
    def createResourceServer(request: CreateResourceServerRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateResourceServerResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateResourceServerRequest,
      CreateResourceServerResponse
    ]("createResourceServer", api.createResourceServer)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateResourceServerResponse.wrap
      )
      .provide(r)
    def adminDisableUser(request: AdminDisableUserRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminDisableUserRequest,
      AdminDisableUserResponse
    ]("adminDisableUser", api.adminDisableUser)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableUserResponse.wrap
      )
      .provide(r)
    def respondToAuthChallenge(request: RespondToAuthChallengeRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.RespondToAuthChallengeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.RespondToAuthChallengeRequest,
      RespondToAuthChallengeResponse
    ]("respondToAuthChallenge", api.respondToAuthChallenge)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.RespondToAuthChallengeResponse.wrap
    ).provide(r)
    def getUser(request: GetUserRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetUserRequest,
      GetUserResponse
    ]("getUser", api.getUser)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserResponse.wrap
      )
      .provide(r)
    def deleteResourceServer(
        request: DeleteResourceServerRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteResourceServerRequest,
      DeleteResourceServerResponse
    ]("deleteResourceServer", api.deleteResourceServer)(
      request.buildAwsValue()
    ).unit.provide(r)
    def listGroups(request: ListGroupsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListGroupsRequest,
      ListGroupsResponse,
      GroupType
    ](
      "listGroups",
      api.listGroups,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.groups().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType
          .wrap(item)
      )
      .provide(r)
    def listDevices(request: ListDevicesRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ListDevicesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListDevicesRequest,
      ListDevicesResponse
    ]("listDevices", api.listDevices)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ListDevicesResponse.wrap
      )
      .provide(r)
    def verifySoftwareToken(request: VerifySoftwareTokenRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifySoftwareTokenResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.VerifySoftwareTokenRequest,
      VerifySoftwareTokenResponse
    ]("verifySoftwareToken", api.verifySoftwareToken)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifySoftwareTokenResponse.wrap
      )
      .provide(r)
    def adminDisableProviderForUser(
        request: AdminDisableProviderForUserRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableProviderForUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminDisableProviderForUserRequest,
      AdminDisableProviderForUserResponse
    ]("adminDisableProviderForUser", api.adminDisableProviderForUser)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableProviderForUserResponse.wrap
    ).provide(r)
    def forgotPassword(request: ForgotPasswordRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ForgotPasswordResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ForgotPasswordRequest,
      ForgotPasswordResponse
    ]("forgotPassword", api.forgotPassword)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ForgotPasswordResponse.wrap
      )
      .provide(r)
    def updateAuthEventFeedback(request: UpdateAuthEventFeedbackRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateAuthEventFeedbackResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateAuthEventFeedbackRequest,
      UpdateAuthEventFeedbackResponse
    ]("updateAuthEventFeedback", api.updateAuthEventFeedback)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateAuthEventFeedbackResponse.wrap
    ).provide(r)
    def updateIdentityProvider(request: UpdateIdentityProviderRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateIdentityProviderResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateIdentityProviderRequest,
      UpdateIdentityProviderResponse
    ]("updateIdentityProvider", api.updateIdentityProvider)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateIdentityProviderResponse.wrap
    ).provide(r)
    def listUserPoolClients(request: ListUserPoolClientsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolClientDescription.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListUserPoolClientsRequest,
      ListUserPoolClientsResponse,
      UserPoolClientDescription
    ](
      "listUserPoolClients",
      api.listUserPoolClients,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.userPoolClients().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolClientDescription
          .wrap(item)
      )
      .provide(r)
    def startUserImportJob(request: StartUserImportJobRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.StartUserImportJobResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.StartUserImportJobRequest,
      StartUserImportJobResponse
    ]("startUserImportJob", api.startUserImportJob)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.StartUserImportJobResponse.wrap
      )
      .provide(r)
    def updateUserAttributes(request: UpdateUserAttributesRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserAttributesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateUserAttributesRequest,
      UpdateUserAttributesResponse
    ]("updateUserAttributes", api.updateUserAttributes)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserAttributesResponse.wrap
      )
      .provide(r)
    def adminListUserAuthEvents(
        request: AdminListUserAuthEventsRequest
    ): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AuthEventType.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminListUserAuthEventsRequest,
      AdminListUserAuthEventsResponse,
      AuthEventType
    ](
      "adminListUserAuthEvents",
      api.adminListUserAuthEvents,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.authEvents().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AuthEventType
          .wrap(item)
      )
      .provide(r)
    def listIdentityProviders(request: ListIdentityProvidersRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ProviderDescription.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListIdentityProvidersRequest,
      ListIdentityProvidersResponse,
      ProviderDescription
    ](
      "listIdentityProviders",
      api.listIdentityProviders,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.providers().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ProviderDescription
          .wrap(item)
      )
      .provide(r)
    def listUserImportJobs(request: ListUserImportJobsRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ListUserImportJobsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListUserImportJobsRequest,
      ListUserImportJobsResponse
    ]("listUserImportJobs", api.listUserImportJobs)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ListUserImportJobsResponse.wrap
      )
      .provide(r)
    def adminCreateUser(request: AdminCreateUserRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminCreateUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminCreateUserRequest,
      AdminCreateUserResponse
    ]("adminCreateUser", api.adminCreateUser)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminCreateUserResponse.wrap
      )
      .provide(r)
    def adminInitiateAuth(request: AdminInitiateAuthRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminInitiateAuthResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminInitiateAuthRequest,
      AdminInitiateAuthResponse
    ]("adminInitiateAuth", api.adminInitiateAuth)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminInitiateAuthResponse.wrap
      )
      .provide(r)
    def confirmSignUp(request: ConfirmSignUpRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmSignUpResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ConfirmSignUpRequest,
      ConfirmSignUpResponse
    ]("confirmSignUp", api.confirmSignUp)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmSignUpResponse.wrap
      )
      .provide(r)
    def adminGetDevice(request: AdminGetDeviceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetDeviceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminGetDeviceRequest,
      AdminGetDeviceResponse
    ]("adminGetDevice", api.adminGetDevice)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetDeviceResponse.wrap
      )
      .provide(r)
    def adminLinkProviderForUser(request: AdminLinkProviderForUserRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminLinkProviderForUserResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminLinkProviderForUserRequest,
      AdminLinkProviderForUserResponse
    ]("adminLinkProviderForUser", api.adminLinkProviderForUser)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminLinkProviderForUserResponse.wrap
    ).provide(r)
    def confirmForgotPassword(request: ConfirmForgotPasswordRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmForgotPasswordResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ConfirmForgotPasswordRequest,
      ConfirmForgotPasswordResponse
    ]("confirmForgotPassword", api.confirmForgotPassword)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmForgotPasswordResponse.wrap
    ).provide(r)
    def setRiskConfiguration(request: SetRiskConfigurationRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.SetRiskConfigurationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.SetRiskConfigurationRequest,
      SetRiskConfigurationResponse
    ]("setRiskConfiguration", api.setRiskConfiguration)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetRiskConfigurationResponse.wrap
      )
      .provide(r)
    def forgetDevice(request: ForgetDeviceRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.cognitoidentityprovider.model.ForgetDeviceRequest,
        ForgetDeviceResponse
      ]("forgetDevice", api.forgetDevice)(request.buildAwsValue()).unit
        .provide(r)
    def deleteUserPool(request: DeleteUserPoolRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteUserPoolRequest,
        DeleteUserPoolResponse
      ]("deleteUserPool", api.deleteUserPool)(request.buildAwsValue()).unit
        .provide(r)
    def untagResource(request: UntagResourceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UntagResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UntagResourceRequest,
      UntagResourceResponse
    ]("untagResource", api.untagResource)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UntagResourceResponse.wrap
      )
      .provide(r)
    def listResourceServers(request: ListResourceServersRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ResourceServerType.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListResourceServersRequest,
      ListResourceServersResponse,
      ResourceServerType
    ](
      "listResourceServers",
      api.listResourceServers,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.resourceServers().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ResourceServerType
          .wrap(item)
      )
      .provide(r)
    def describeUserImportJob(request: DescribeUserImportJobRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserImportJobResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeUserImportJobRequest,
      DescribeUserImportJobResponse
    ]("describeUserImportJob", api.describeUserImportJob)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserImportJobResponse.wrap
    ).provide(r)
    def deleteUserPoolDomain(request: DeleteUserPoolDomainRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserPoolDomainResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteUserPoolDomainRequest,
      DeleteUserPoolDomainResponse
    ]("deleteUserPoolDomain", api.deleteUserPoolDomain)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserPoolDomainResponse.wrap
      )
      .provide(r)
    def setUserSettings(request: SetUserSettingsRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserSettingsResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.SetUserSettingsRequest,
      SetUserSettingsResponse
    ]("setUserSettings", api.setUserSettings)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserSettingsResponse.wrap
      )
      .provide(r)
    def adminDeleteUser(request: AdminDeleteUserRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.cognitoidentityprovider.model.AdminDeleteUserRequest,
        AdminDeleteUserResponse
      ]("adminDeleteUser", api.adminDeleteUser)(request.buildAwsValue()).unit
        .provide(r)
    def adminRespondToAuthChallenge(
        request: AdminRespondToAuthChallengeRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminRespondToAuthChallengeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminRespondToAuthChallengeRequest,
      AdminRespondToAuthChallengeResponse
    ]("adminRespondToAuthChallenge", api.adminRespondToAuthChallenge)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminRespondToAuthChallengeResponse.wrap
    ).provide(r)
    def createGroup(request: CreateGroupRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateGroupRequest,
      CreateGroupResponse
    ]("createGroup", api.createGroup)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateGroupResponse.wrap
      )
      .provide(r)
    def adminAddUserToGroup(
        request: AdminAddUserToGroupRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminAddUserToGroupRequest,
      AdminAddUserToGroupResponse
    ]("adminAddUserToGroup", api.adminAddUserToGroup)(
      request.buildAwsValue()
    ).unit.provide(r)
    def adminSetUserPassword(request: AdminSetUserPasswordRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserPasswordResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminSetUserPasswordRequest,
      AdminSetUserPasswordResponse
    ]("adminSetUserPassword", api.adminSetUserPassword)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserPasswordResponse.wrap
      )
      .provide(r)
    def setUserMFAPreference(request: SetUserMfaPreferenceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserMfaPreferenceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.SetUserMfaPreferenceRequest,
      SetUserMfaPreferenceResponse
    ]("setUserMFAPreference", api.setUserMFAPreference)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserMfaPreferenceResponse.wrap
      )
      .provide(r)
    def updateUserPoolDomain(request: UpdateUserPoolDomainRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolDomainResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateUserPoolDomainRequest,
      UpdateUserPoolDomainResponse
    ]("updateUserPoolDomain", api.updateUserPoolDomain)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolDomainResponse.wrap
      )
      .provide(r)
    def setUICustomization(request: SetUiCustomizationRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUiCustomizationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.SetUiCustomizationRequest,
      SetUiCustomizationResponse
    ]("setUICustomization", api.setUICustomization)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUiCustomizationResponse.wrap
      )
      .provide(r)
    def listTagsForResource(request: ListTagsForResourceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ListTagsForResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListTagsForResourceRequest,
      ListTagsForResourceResponse
    ]("listTagsForResource", api.listTagsForResource)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ListTagsForResourceResponse.wrap
      )
      .provide(r)
    def updateGroup(request: UpdateGroupRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateGroupRequest,
      UpdateGroupResponse
    ]("updateGroup", api.updateGroup)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateGroupResponse.wrap
      )
      .provide(r)
    def confirmDevice(request: ConfirmDeviceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmDeviceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ConfirmDeviceRequest,
      ConfirmDeviceResponse
    ]("confirmDevice", api.confirmDevice)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmDeviceResponse.wrap
      )
      .provide(r)
    def tagResource(request: TagResourceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.TagResourceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.TagResourceRequest,
      TagResourceResponse
    ]("tagResource", api.tagResource)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.TagResourceResponse.wrap
      )
      .provide(r)
    def adminDeleteUserAttributes(
        request: AdminDeleteUserAttributesRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDeleteUserAttributesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminDeleteUserAttributesRequest,
      AdminDeleteUserAttributesResponse
    ]("adminDeleteUserAttributes", api.adminDeleteUserAttributes)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDeleteUserAttributesResponse.wrap
    ).provide(r)
    def adminForgetDevice(
        request: AdminForgetDeviceRequest
    ): IO[AwsError, Unit] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminForgetDeviceRequest,
      AdminForgetDeviceResponse
    ]("adminForgetDevice", api.adminForgetDevice)(request.buildAwsValue()).unit
      .provide(r)
    def createUserPool(request: CreateUserPoolRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolRequest,
      CreateUserPoolResponse
    ]("createUserPool", api.createUserPool)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolResponse.wrap
      )
      .provide(r)
    def deleteUser(request: DeleteUserRequest): IO[AwsError, Unit] =
      asyncRequestResponse[
        software.amazon.awssdk.services.cognitoidentityprovider.model.DeleteUserRequest,
        DeleteUserResponse
      ]("deleteUser", api.deleteUser)(request.buildAwsValue()).unit.provide(r)
    def createUserImportJob(request: CreateUserImportJobRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserImportJobResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserImportJobRequest,
      CreateUserImportJobResponse
    ]("createUserImportJob", api.createUserImportJob)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserImportJobResponse.wrap
      )
      .provide(r)
    def getGroup(request: GetGroupRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetGroupResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetGroupRequest,
      GetGroupResponse
    ]("getGroup", api.getGroup)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetGroupResponse.wrap
      )
      .provide(r)
    def createUserPoolClient(request: CreateUserPoolClientRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolClientResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolClientRequest,
      CreateUserPoolClientResponse
    ]("createUserPoolClient", api.createUserPoolClient)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolClientResponse.wrap
      )
      .provide(r)
    def updateUserPool(request: UpdateUserPoolRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateUserPoolRequest,
      UpdateUserPoolResponse
    ]("updateUserPool", api.updateUserPool)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolResponse.wrap
      )
      .provide(r)
    def updateDeviceStatus(request: UpdateDeviceStatusRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateDeviceStatusResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateDeviceStatusRequest,
      UpdateDeviceStatusResponse
    ]("updateDeviceStatus", api.updateDeviceStatus)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateDeviceStatusResponse.wrap
      )
      .provide(r)
    def describeUserPoolClient(request: DescribeUserPoolClientRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolClientResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeUserPoolClientRequest,
      DescribeUserPoolClientResponse
    ]("describeUserPoolClient", api.describeUserPoolClient)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolClientResponse.wrap
    ).provide(r)
    def getCSVHeader(request: GetCsvHeaderRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetCsvHeaderResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetCsvHeaderRequest,
      GetCsvHeaderResponse
    ]("getCSVHeader", api.getCSVHeader)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetCsvHeaderResponse.wrap
      )
      .provide(r)
    def describeResourceServer(request: DescribeResourceServerRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeResourceServerResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeResourceServerRequest,
      DescribeResourceServerResponse
    ]("describeResourceServer", api.describeResourceServer)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeResourceServerResponse.wrap
    ).provide(r)
    def setUserPoolMfaConfig(request: SetUserPoolMfaConfigRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserPoolMfaConfigResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.SetUserPoolMfaConfigRequest,
      SetUserPoolMfaConfigResponse
    ]("setUserPoolMfaConfig", api.setUserPoolMfaConfig)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserPoolMfaConfigResponse.wrap
      )
      .provide(r)
    def describeRiskConfiguration(
        request: DescribeRiskConfigurationRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeRiskConfigurationResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.DescribeRiskConfigurationRequest,
      DescribeRiskConfigurationResponse
    ]("describeRiskConfiguration", api.describeRiskConfiguration)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeRiskConfigurationResponse.wrap
    ).provide(r)
    def listUserPools(request: ListUserPoolsRequest): ZStream[
      Any,
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolDescriptionType.ReadOnly
    ] = asyncSimplePaginatedRequest[
      software.amazon.awssdk.services.cognitoidentityprovider.model.ListUserPoolsRequest,
      ListUserPoolsResponse,
      UserPoolDescriptionType
    ](
      "listUserPools",
      api.listUserPools,
      (r, token) => r.toBuilder().nextToken(token).build(),
      r => scala.Option(r.nextToken()),
      r => zio.Chunk.fromIterable(r.userPools().asScala)
    )(request.buildAwsValue())
      .map(item =>
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolDescriptionType
          .wrap(item)
      )
      .provide(r)
    def adminListDevices(request: AdminListDevicesRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminListDevicesResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminListDevicesRequest,
      AdminListDevicesResponse
    ]("adminListDevices", api.adminListDevices)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminListDevicesResponse.wrap
      )
      .provide(r)
    def getDevice(request: GetDeviceRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetDeviceResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetDeviceRequest,
      GetDeviceResponse
    ]("getDevice", api.getDevice)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.GetDeviceResponse.wrap
      )
      .provide(r)
    def adminSetUserMFAPreference(
        request: AdminSetUserMfaPreferenceRequest
    ): IO[AwsError, ReadOnly] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.AdminSetUserMfaPreferenceRequest,
      AdminSetUserMfaPreferenceResponse
    ]("adminSetUserMFAPreference", api.adminSetUserMFAPreference)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserMfaPreferenceResponse.wrap
    ).provide(r)
    def updateResourceServer(request: UpdateResourceServerRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateResourceServerResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.UpdateResourceServerRequest,
      UpdateResourceServerResponse
    ]("updateResourceServer", api.updateResourceServer)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateResourceServerResponse.wrap
      )
      .provide(r)
    def verifyUserAttribute(request: VerifyUserAttributeRequest): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifyUserAttributeResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.VerifyUserAttributeRequest,
      VerifyUserAttributeResponse
    ]("verifyUserAttribute", api.verifyUserAttribute)(request.buildAwsValue())
      .map(
        io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifyUserAttributeResponse.wrap
      )
      .provide(r)
    def getIdentityProviderByIdentifier(
        request: GetIdentityProviderByIdentifierRequest
    ): IO[
      AwsError,
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetIdentityProviderByIdentifierResponse.ReadOnly
    ] = asyncRequestResponse[
      software.amazon.awssdk.services.cognitoidentityprovider.model.GetIdentityProviderByIdentifierRequest,
      GetIdentityProviderByIdentifierResponse
    ]("getIdentityProviderByIdentifier", api.getIdentityProviderByIdentifier)(
      request.buildAwsValue()
    ).map(
      io.github.vigoo.zioaws.cognitoidentityprovider.model.GetIdentityProviderByIdentifierResponse.wrap
    ).provide(r)
  }
  def adminConfirmSignUp(request: AdminConfirmSignUpRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminConfirmSignUpResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminConfirmSignUp(request))
  def createIdentityProvider(request: CreateIdentityProviderRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateIdentityProviderResponse.ReadOnly
  ] = ZIO.accessM(_.get.createIdentityProvider(request))
  def adminEnableUser(request: AdminEnableUserRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminEnableUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminEnableUser(request))
  def revokeToken(request: RevokeTokenRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.RevokeTokenResponse.ReadOnly
  ] = ZIO.accessM(_.get.revokeToken(request))
  def stopUserImportJob(request: StopUserImportJobRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.StopUserImportJobResponse.ReadOnly
  ] = ZIO.accessM(_.get.stopUserImportJob(request))
  def adminRemoveUserFromGroup(
      request: AdminRemoveUserFromGroupRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.adminRemoveUserFromGroup(request))
  def describeUserPoolDomain(request: DescribeUserPoolDomainRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolDomainResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeUserPoolDomain(request))
  def listUsers(request: ListUsersRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
  ] = ZStream.accessStream(_.get.listUsers(request))
  def listUsersInGroup(request: ListUsersInGroupRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UserType.ReadOnly
  ] = ZStream.accessStream(_.get.listUsersInGroup(request))
  def globalSignOut(request: GlobalSignOutRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GlobalSignOutResponse.ReadOnly
  ] = ZIO.accessM(_.get.globalSignOut(request))
  def adminGetUser(request: AdminGetUserRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminGetUser(request))
  def createUserPoolDomain(request: CreateUserPoolDomainRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolDomainResponse.ReadOnly
  ] = ZIO.accessM(_.get.createUserPoolDomain(request))
  def associateSoftwareToken(request: AssociateSoftwareTokenRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AssociateSoftwareTokenResponse.ReadOnly
  ] = ZIO.accessM(_.get.associateSoftwareToken(request))
  def adminUpdateAuthEventFeedback(
      request: AdminUpdateAuthEventFeedbackRequest
  ): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateAuthEventFeedbackResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminUpdateAuthEventFeedback(request))
  def describeUserPool(request: DescribeUserPoolRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeUserPool(request))
  def describeIdentityProvider(request: DescribeIdentityProviderRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeIdentityProviderResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeIdentityProvider(request))
  def adminUpdateDeviceStatus(request: AdminUpdateDeviceStatusRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateDeviceStatusResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminUpdateDeviceStatus(request))
  def adminUpdateUserAttributes(request: AdminUpdateUserAttributesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUpdateUserAttributesResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminUpdateUserAttributes(request))
  def resendConfirmationCode(request: ResendConfirmationCodeRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ResendConfirmationCodeResponse.ReadOnly
  ] = ZIO.accessM(_.get.resendConfirmationCode(request))
  def signUp(request: SignUpRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.SignUpResponse.ReadOnly
  ] = ZIO.accessM(_.get.signUp(request))
  def deleteIdentityProvider(
      request: DeleteIdentityProviderRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.deleteIdentityProvider(request))
  def getUserAttributeVerificationCode(
      request: GetUserAttributeVerificationCodeRequest
  ): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserAttributeVerificationCodeResponse.ReadOnly
  ] = ZIO.accessM(_.get.getUserAttributeVerificationCode(request))
  def deleteUserPoolClient(
      request: DeleteUserPoolClientRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.deleteUserPoolClient(request))
  def deleteGroup(
      request: DeleteGroupRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.deleteGroup(request))
  def adminSetUserSettings(request: AdminSetUserSettingsRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserSettingsResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminSetUserSettings(request))
  def getSigningCertificate(request: GetSigningCertificateRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetSigningCertificateResponse.ReadOnly
  ] = ZIO.accessM(_.get.getSigningCertificate(request))
  def getUserPoolMfaConfig(request: GetUserPoolMfaConfigRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserPoolMfaConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.getUserPoolMfaConfig(request))
  def updateUserPoolClient(request: UpdateUserPoolClientRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolClientResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateUserPoolClient(request))
  def initiateAuth(request: InitiateAuthRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.InitiateAuthResponse.ReadOnly
  ] = ZIO.accessM(_.get.initiateAuth(request))
  def changePassword(request: ChangePasswordRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ChangePasswordResponse.ReadOnly
  ] = ZIO.accessM(_.get.changePassword(request))
  def adminListGroupsForUser(request: AdminListGroupsForUserRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
  ] = ZStream.accessStream(_.get.adminListGroupsForUser(request))
  def deleteUserAttributes(request: DeleteUserAttributesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserAttributesResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteUserAttributes(request))
  def adminResetUserPassword(request: AdminResetUserPasswordRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminResetUserPasswordResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminResetUserPassword(request))
  def addCustomAttributes(request: AddCustomAttributesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AddCustomAttributesResponse.ReadOnly
  ] = ZIO.accessM(_.get.addCustomAttributes(request))
  def adminUserGlobalSignOut(request: AdminUserGlobalSignOutRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminUserGlobalSignOutResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminUserGlobalSignOut(request))
  def getUICustomization(request: GetUiCustomizationRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUiCustomizationResponse.ReadOnly
  ] = ZIO.accessM(_.get.getUICustomization(request))
  def createResourceServer(request: CreateResourceServerRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateResourceServerResponse.ReadOnly
  ] = ZIO.accessM(_.get.createResourceServer(request))
  def adminDisableUser(request: AdminDisableUserRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminDisableUser(request))
  def respondToAuthChallenge(request: RespondToAuthChallengeRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.RespondToAuthChallengeResponse.ReadOnly
  ] = ZIO.accessM(_.get.respondToAuthChallenge(request))
  def getUser(request: GetUserRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.getUser(request))
  def deleteResourceServer(
      request: DeleteResourceServerRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.deleteResourceServer(request))
  def listGroups(request: ListGroupsRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GroupType.ReadOnly
  ] = ZStream.accessStream(_.get.listGroups(request))
  def listDevices(request: ListDevicesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ListDevicesResponse.ReadOnly
  ] = ZIO.accessM(_.get.listDevices(request))
  def verifySoftwareToken(request: VerifySoftwareTokenRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifySoftwareTokenResponse.ReadOnly
  ] = ZIO.accessM(_.get.verifySoftwareToken(request))
  def adminDisableProviderForUser(
      request: AdminDisableProviderForUserRequest
  ): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDisableProviderForUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminDisableProviderForUser(request))
  def forgotPassword(request: ForgotPasswordRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ForgotPasswordResponse.ReadOnly
  ] = ZIO.accessM(_.get.forgotPassword(request))
  def updateAuthEventFeedback(request: UpdateAuthEventFeedbackRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateAuthEventFeedbackResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateAuthEventFeedback(request))
  def updateIdentityProvider(request: UpdateIdentityProviderRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateIdentityProviderResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateIdentityProvider(request))
  def listUserPoolClients(request: ListUserPoolClientsRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolClientDescription.ReadOnly
  ] = ZStream.accessStream(_.get.listUserPoolClients(request))
  def startUserImportJob(request: StartUserImportJobRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.StartUserImportJobResponse.ReadOnly
  ] = ZIO.accessM(_.get.startUserImportJob(request))
  def updateUserAttributes(request: UpdateUserAttributesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserAttributesResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateUserAttributes(request))
  def adminListUserAuthEvents(request: AdminListUserAuthEventsRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AuthEventType.ReadOnly
  ] = ZStream.accessStream(_.get.adminListUserAuthEvents(request))
  def listIdentityProviders(request: ListIdentityProvidersRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ProviderDescription.ReadOnly
  ] = ZStream.accessStream(_.get.listIdentityProviders(request))
  def listUserImportJobs(request: ListUserImportJobsRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ListUserImportJobsResponse.ReadOnly
  ] = ZIO.accessM(_.get.listUserImportJobs(request))
  def adminCreateUser(request: AdminCreateUserRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminCreateUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminCreateUser(request))
  def adminInitiateAuth(request: AdminInitiateAuthRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminInitiateAuthResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminInitiateAuth(request))
  def confirmSignUp(request: ConfirmSignUpRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmSignUpResponse.ReadOnly
  ] = ZIO.accessM(_.get.confirmSignUp(request))
  def adminGetDevice(request: AdminGetDeviceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminGetDeviceResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminGetDevice(request))
  def adminLinkProviderForUser(request: AdminLinkProviderForUserRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminLinkProviderForUserResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminLinkProviderForUser(request))
  def confirmForgotPassword(request: ConfirmForgotPasswordRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmForgotPasswordResponse.ReadOnly
  ] = ZIO.accessM(_.get.confirmForgotPassword(request))
  def setRiskConfiguration(request: SetRiskConfigurationRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.SetRiskConfigurationResponse.ReadOnly
  ] = ZIO.accessM(_.get.setRiskConfiguration(request))
  def forgetDevice(
      request: ForgetDeviceRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.forgetDevice(request))
  def deleteUserPool(
      request: DeleteUserPoolRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.deleteUserPool(request))
  def untagResource(request: UntagResourceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UntagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.untagResource(request))
  def listResourceServers(request: ListResourceServersRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ResourceServerType.ReadOnly
  ] = ZStream.accessStream(_.get.listResourceServers(request))
  def describeUserImportJob(request: DescribeUserImportJobRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserImportJobResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeUserImportJob(request))
  def deleteUserPoolDomain(request: DeleteUserPoolDomainRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DeleteUserPoolDomainResponse.ReadOnly
  ] = ZIO.accessM(_.get.deleteUserPoolDomain(request))
  def setUserSettings(request: SetUserSettingsRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserSettingsResponse.ReadOnly
  ] = ZIO.accessM(_.get.setUserSettings(request))
  def adminDeleteUser(
      request: AdminDeleteUserRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.adminDeleteUser(request))
  def adminRespondToAuthChallenge(
      request: AdminRespondToAuthChallengeRequest
  ): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminRespondToAuthChallengeResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminRespondToAuthChallenge(request))
  def createGroup(request: CreateGroupRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.createGroup(request))
  def adminAddUserToGroup(
      request: AdminAddUserToGroupRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.adminAddUserToGroup(request))
  def adminSetUserPassword(request: AdminSetUserPasswordRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminSetUserPasswordResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminSetUserPassword(request))
  def setUserMFAPreference(request: SetUserMfaPreferenceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserMfaPreferenceResponse.ReadOnly
  ] = ZIO.accessM(_.get.setUserMFAPreference(request))
  def updateUserPoolDomain(request: UpdateUserPoolDomainRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolDomainResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateUserPoolDomain(request))
  def setUICustomization(request: SetUiCustomizationRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUiCustomizationResponse.ReadOnly
  ] = ZIO.accessM(_.get.setUICustomization(request))
  def listTagsForResource(request: ListTagsForResourceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ListTagsForResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.listTagsForResource(request))
  def updateGroup(request: UpdateGroupRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateGroup(request))
  def confirmDevice(request: ConfirmDeviceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.ConfirmDeviceResponse.ReadOnly
  ] = ZIO.accessM(_.get.confirmDevice(request))
  def tagResource(request: TagResourceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.TagResourceResponse.ReadOnly
  ] = ZIO.accessM(_.get.tagResource(request))
  def adminDeleteUserAttributes(request: AdminDeleteUserAttributesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminDeleteUserAttributesResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminDeleteUserAttributes(request))
  def adminForgetDevice(
      request: AdminForgetDeviceRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.adminForgetDevice(request))
  def createUserPool(request: CreateUserPoolRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolResponse.ReadOnly
  ] = ZIO.accessM(_.get.createUserPool(request))
  def deleteUser(
      request: DeleteUserRequest
  ): ZIO[CognitoIdentityProvider, AwsError, Unit] =
    ZIO.accessM(_.get.deleteUser(request))
  def createUserImportJob(request: CreateUserImportJobRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserImportJobResponse.ReadOnly
  ] = ZIO.accessM(_.get.createUserImportJob(request))
  def getGroup(request: GetGroupRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetGroupResponse.ReadOnly
  ] = ZIO.accessM(_.get.getGroup(request))
  def createUserPoolClient(request: CreateUserPoolClientRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.CreateUserPoolClientResponse.ReadOnly
  ] = ZIO.accessM(_.get.createUserPoolClient(request))
  def updateUserPool(request: UpdateUserPoolRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateUserPoolResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateUserPool(request))
  def updateDeviceStatus(request: UpdateDeviceStatusRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateDeviceStatusResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateDeviceStatus(request))
  def describeUserPoolClient(request: DescribeUserPoolClientRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeUserPoolClientResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeUserPoolClient(request))
  def getCSVHeader(request: GetCsvHeaderRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetCsvHeaderResponse.ReadOnly
  ] = ZIO.accessM(_.get.getCSVHeader(request))
  def describeResourceServer(request: DescribeResourceServerRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeResourceServerResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeResourceServer(request))
  def setUserPoolMfaConfig(request: SetUserPoolMfaConfigRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.SetUserPoolMfaConfigResponse.ReadOnly
  ] = ZIO.accessM(_.get.setUserPoolMfaConfig(request))
  def describeRiskConfiguration(request: DescribeRiskConfigurationRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.DescribeRiskConfigurationResponse.ReadOnly
  ] = ZIO.accessM(_.get.describeRiskConfiguration(request))
  def listUserPools(request: ListUserPoolsRequest): ZStream[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UserPoolDescriptionType.ReadOnly
  ] = ZStream.accessStream(_.get.listUserPools(request))
  def adminListDevices(request: AdminListDevicesRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.AdminListDevicesResponse.ReadOnly
  ] = ZIO.accessM(_.get.adminListDevices(request))
  def getDevice(request: GetDeviceRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetDeviceResponse.ReadOnly
  ] = ZIO.accessM(_.get.getDevice(request))
  def adminSetUserMFAPreference(
      request: AdminSetUserMfaPreferenceRequest
  ): ZIO[CognitoIdentityProvider, AwsError, ReadOnly] =
    ZIO.accessM(_.get.adminSetUserMFAPreference(request))
  def updateResourceServer(request: UpdateResourceServerRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.UpdateResourceServerResponse.ReadOnly
  ] = ZIO.accessM(_.get.updateResourceServer(request))
  def verifyUserAttribute(request: VerifyUserAttributeRequest): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.VerifyUserAttributeResponse.ReadOnly
  ] = ZIO.accessM(_.get.verifyUserAttribute(request))
  def getIdentityProviderByIdentifier(
      request: GetIdentityProviderByIdentifierRequest
  ): ZIO[
    CognitoIdentityProvider,
    AwsError,
    io.github.vigoo.zioaws.cognitoidentityprovider.model.GetIdentityProviderByIdentifierResponse.ReadOnly
  ] = ZIO.accessM(_.get.getIdentityProviderByIdentifier(request))
}