diff --git a/docs/resources/cognito-user-pool.md b/docs/resources/cognito-user-pool.md
new file mode 100644
index 00000000..709b37db
--- /dev/null
+++ b/docs/resources/cognito-user-pool.md
@@ -0,0 +1,19 @@
+# Cognito User Pool
+
+**ResourceType:** `CognitoUserPool`
+
+## Settings
+
+- `DisableDeletionProtection`
+
+### DisableDeletionProtection
+
+Specifies whether deletion protection should be disabled prior to deleting the Cognito User Pool. Default is `false`.
+
+## Example Configuration
+
+```yaml
+settings:
+  CognitoUserPool:
+    DisableDeletionProtection: true
+```
diff --git a/go.mod b/go.mod
index 45c4cc7c..78448ebc 100644
--- a/go.mod
+++ b/go.mod
@@ -32,8 +32,10 @@ require (
 	github.com/russross/blackfriday/v2 v2.1.0 // indirect
 	github.com/stevenle/topsort v0.2.0 // indirect
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
+	golang.org/x/mod v0.17.0 // indirect
 	golang.org/x/sync v0.8.0 // indirect
 	golang.org/x/sys v0.20.0 // indirect
+	golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
 	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 )
diff --git a/go.sum b/go.sum
index f155c702..3bde2c59 100644
--- a/go.sum
+++ b/go.sum
@@ -66,6 +66,8 @@ go.uber.org/ratelimit v0.3.1/go.mod h1:6euWsTB6U/Nb3X++xEUXA8ciPJvr19Q/0h1+oDcJh
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
@@ -91,6 +93,8 @@ golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
diff --git a/mkdocs.yml b/mkdocs.yml
index c40137c1..751996cd 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -91,7 +91,8 @@ nav:
     - Custom Endpoints: config-custom-endpoints.md
     - Migration Guide: config-migration.md
   - Resources:
-      S3 Bucket: resources/s3-bucket.md
+    - Cognito User Pool: resources/cognito-user-pool.md
+    - S3 Bucket: resources/s3-bucket.md
   - Development:
     - Overview: development.md
     - Contributing: contributing.md
diff --git a/mocks/mock_cognitoidentityprovideriface/mock.go b/mocks/mock_cognitoidentityprovideriface/mock.go
new file mode 100644
index 00000000..dfa97a78
--- /dev/null
+++ b/mocks/mock_cognitoidentityprovideriface/mock.go
@@ -0,0 +1,5484 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: /Users/ekristen/go/pkg/mod/github.com/aws/aws-sdk-go@v1.54.20/service/cognitoidentityprovider/cognitoidentityprovideriface/interface.go
+
+// Package mock_cognitoidentityprovideriface is a generated GoMock package.
+package mock_cognitoidentityprovideriface
+
+import (
+	reflect "reflect"
+
+	aws "github.com/aws/aws-sdk-go/aws"
+	request "github.com/aws/aws-sdk-go/aws/request"
+	cognitoidentityprovider "github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
+	gomock "github.com/golang/mock/gomock"
+)
+
+// MockCognitoIdentityProviderAPI is a mock of CognitoIdentityProviderAPI interface.
+type MockCognitoIdentityProviderAPI struct {
+	ctrl     *gomock.Controller
+	recorder *MockCognitoIdentityProviderAPIMockRecorder
+}
+
+// MockCognitoIdentityProviderAPIMockRecorder is the mock recorder for MockCognitoIdentityProviderAPI.
+type MockCognitoIdentityProviderAPIMockRecorder struct {
+	mock *MockCognitoIdentityProviderAPI
+}
+
+// NewMockCognitoIdentityProviderAPI creates a new mock instance.
+func NewMockCognitoIdentityProviderAPI(ctrl *gomock.Controller) *MockCognitoIdentityProviderAPI {
+	mock := &MockCognitoIdentityProviderAPI{ctrl: ctrl}
+	mock.recorder = &MockCognitoIdentityProviderAPIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockCognitoIdentityProviderAPI) EXPECT() *MockCognitoIdentityProviderAPIMockRecorder {
+	return m.recorder
+}
+
+// AddCustomAttributes mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AddCustomAttributes(arg0 *cognitoidentityprovider.AddCustomAttributesInput) (*cognitoidentityprovider.AddCustomAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddCustomAttributes", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AddCustomAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddCustomAttributes indicates an expected call of AddCustomAttributes.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AddCustomAttributes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCustomAttributes", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AddCustomAttributes), arg0)
+}
+
+// AddCustomAttributesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AddCustomAttributesRequest(arg0 *cognitoidentityprovider.AddCustomAttributesInput) (*request.Request, *cognitoidentityprovider.AddCustomAttributesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddCustomAttributesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AddCustomAttributesOutput)
+	return ret0, ret1
+}
+
+// AddCustomAttributesRequest indicates an expected call of AddCustomAttributesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AddCustomAttributesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCustomAttributesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AddCustomAttributesRequest), arg0)
+}
+
+// AddCustomAttributesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AddCustomAttributesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AddCustomAttributesInput, arg2 ...request.Option) (*cognitoidentityprovider.AddCustomAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AddCustomAttributesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AddCustomAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AddCustomAttributesWithContext indicates an expected call of AddCustomAttributesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AddCustomAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCustomAttributesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AddCustomAttributesWithContext), varargs...)
+}
+
+// AdminAddUserToGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminAddUserToGroup(arg0 *cognitoidentityprovider.AdminAddUserToGroupInput) (*cognitoidentityprovider.AdminAddUserToGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminAddUserToGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminAddUserToGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminAddUserToGroup indicates an expected call of AdminAddUserToGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminAddUserToGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminAddUserToGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminAddUserToGroup), arg0)
+}
+
+// AdminAddUserToGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminAddUserToGroupRequest(arg0 *cognitoidentityprovider.AdminAddUserToGroupInput) (*request.Request, *cognitoidentityprovider.AdminAddUserToGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminAddUserToGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminAddUserToGroupOutput)
+	return ret0, ret1
+}
+
+// AdminAddUserToGroupRequest indicates an expected call of AdminAddUserToGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminAddUserToGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminAddUserToGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminAddUserToGroupRequest), arg0)
+}
+
+// AdminAddUserToGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminAddUserToGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminAddUserToGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminAddUserToGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminAddUserToGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminAddUserToGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminAddUserToGroupWithContext indicates an expected call of AdminAddUserToGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminAddUserToGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminAddUserToGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminAddUserToGroupWithContext), varargs...)
+}
+
+// AdminConfirmSignUp mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminConfirmSignUp(arg0 *cognitoidentityprovider.AdminConfirmSignUpInput) (*cognitoidentityprovider.AdminConfirmSignUpOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminConfirmSignUp", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminConfirmSignUpOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminConfirmSignUp indicates an expected call of AdminConfirmSignUp.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminConfirmSignUp(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminConfirmSignUp", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminConfirmSignUp), arg0)
+}
+
+// AdminConfirmSignUpRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminConfirmSignUpRequest(arg0 *cognitoidentityprovider.AdminConfirmSignUpInput) (*request.Request, *cognitoidentityprovider.AdminConfirmSignUpOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminConfirmSignUpRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminConfirmSignUpOutput)
+	return ret0, ret1
+}
+
+// AdminConfirmSignUpRequest indicates an expected call of AdminConfirmSignUpRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminConfirmSignUpRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminConfirmSignUpRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminConfirmSignUpRequest), arg0)
+}
+
+// AdminConfirmSignUpWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminConfirmSignUpWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminConfirmSignUpInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminConfirmSignUpOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminConfirmSignUpWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminConfirmSignUpOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminConfirmSignUpWithContext indicates an expected call of AdminConfirmSignUpWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminConfirmSignUpWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminConfirmSignUpWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminConfirmSignUpWithContext), varargs...)
+}
+
+// AdminCreateUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminCreateUser(arg0 *cognitoidentityprovider.AdminCreateUserInput) (*cognitoidentityprovider.AdminCreateUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminCreateUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminCreateUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminCreateUser indicates an expected call of AdminCreateUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminCreateUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminCreateUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminCreateUser), arg0)
+}
+
+// AdminCreateUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminCreateUserRequest(arg0 *cognitoidentityprovider.AdminCreateUserInput) (*request.Request, *cognitoidentityprovider.AdminCreateUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminCreateUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminCreateUserOutput)
+	return ret0, ret1
+}
+
+// AdminCreateUserRequest indicates an expected call of AdminCreateUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminCreateUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminCreateUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminCreateUserRequest), arg0)
+}
+
+// AdminCreateUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminCreateUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminCreateUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminCreateUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminCreateUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminCreateUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminCreateUserWithContext indicates an expected call of AdminCreateUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminCreateUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminCreateUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminCreateUserWithContext), varargs...)
+}
+
+// AdminDeleteUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDeleteUser(arg0 *cognitoidentityprovider.AdminDeleteUserInput) (*cognitoidentityprovider.AdminDeleteUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDeleteUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDeleteUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDeleteUser indicates an expected call of AdminDeleteUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDeleteUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDeleteUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDeleteUser), arg0)
+}
+
+// AdminDeleteUserAttributes mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDeleteUserAttributes(arg0 *cognitoidentityprovider.AdminDeleteUserAttributesInput) (*cognitoidentityprovider.AdminDeleteUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDeleteUserAttributes", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDeleteUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDeleteUserAttributes indicates an expected call of AdminDeleteUserAttributes.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDeleteUserAttributes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDeleteUserAttributes", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDeleteUserAttributes), arg0)
+}
+
+// AdminDeleteUserAttributesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDeleteUserAttributesRequest(arg0 *cognitoidentityprovider.AdminDeleteUserAttributesInput) (*request.Request, *cognitoidentityprovider.AdminDeleteUserAttributesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDeleteUserAttributesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminDeleteUserAttributesOutput)
+	return ret0, ret1
+}
+
+// AdminDeleteUserAttributesRequest indicates an expected call of AdminDeleteUserAttributesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDeleteUserAttributesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDeleteUserAttributesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDeleteUserAttributesRequest), arg0)
+}
+
+// AdminDeleteUserAttributesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDeleteUserAttributesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminDeleteUserAttributesInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminDeleteUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminDeleteUserAttributesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDeleteUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDeleteUserAttributesWithContext indicates an expected call of AdminDeleteUserAttributesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDeleteUserAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDeleteUserAttributesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDeleteUserAttributesWithContext), varargs...)
+}
+
+// AdminDeleteUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDeleteUserRequest(arg0 *cognitoidentityprovider.AdminDeleteUserInput) (*request.Request, *cognitoidentityprovider.AdminDeleteUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDeleteUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminDeleteUserOutput)
+	return ret0, ret1
+}
+
+// AdminDeleteUserRequest indicates an expected call of AdminDeleteUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDeleteUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDeleteUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDeleteUserRequest), arg0)
+}
+
+// AdminDeleteUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDeleteUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminDeleteUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminDeleteUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminDeleteUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDeleteUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDeleteUserWithContext indicates an expected call of AdminDeleteUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDeleteUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDeleteUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDeleteUserWithContext), varargs...)
+}
+
+// AdminDisableProviderForUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDisableProviderForUser(arg0 *cognitoidentityprovider.AdminDisableProviderForUserInput) (*cognitoidentityprovider.AdminDisableProviderForUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDisableProviderForUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDisableProviderForUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDisableProviderForUser indicates an expected call of AdminDisableProviderForUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDisableProviderForUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDisableProviderForUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDisableProviderForUser), arg0)
+}
+
+// AdminDisableProviderForUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDisableProviderForUserRequest(arg0 *cognitoidentityprovider.AdminDisableProviderForUserInput) (*request.Request, *cognitoidentityprovider.AdminDisableProviderForUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDisableProviderForUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminDisableProviderForUserOutput)
+	return ret0, ret1
+}
+
+// AdminDisableProviderForUserRequest indicates an expected call of AdminDisableProviderForUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDisableProviderForUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDisableProviderForUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDisableProviderForUserRequest), arg0)
+}
+
+// AdminDisableProviderForUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDisableProviderForUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminDisableProviderForUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminDisableProviderForUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminDisableProviderForUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDisableProviderForUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDisableProviderForUserWithContext indicates an expected call of AdminDisableProviderForUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDisableProviderForUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDisableProviderForUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDisableProviderForUserWithContext), varargs...)
+}
+
+// AdminDisableUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDisableUser(arg0 *cognitoidentityprovider.AdminDisableUserInput) (*cognitoidentityprovider.AdminDisableUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDisableUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDisableUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDisableUser indicates an expected call of AdminDisableUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDisableUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDisableUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDisableUser), arg0)
+}
+
+// AdminDisableUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDisableUserRequest(arg0 *cognitoidentityprovider.AdminDisableUserInput) (*request.Request, *cognitoidentityprovider.AdminDisableUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminDisableUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminDisableUserOutput)
+	return ret0, ret1
+}
+
+// AdminDisableUserRequest indicates an expected call of AdminDisableUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDisableUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDisableUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDisableUserRequest), arg0)
+}
+
+// AdminDisableUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminDisableUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminDisableUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminDisableUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminDisableUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminDisableUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminDisableUserWithContext indicates an expected call of AdminDisableUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminDisableUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminDisableUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminDisableUserWithContext), varargs...)
+}
+
+// AdminEnableUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminEnableUser(arg0 *cognitoidentityprovider.AdminEnableUserInput) (*cognitoidentityprovider.AdminEnableUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminEnableUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminEnableUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminEnableUser indicates an expected call of AdminEnableUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminEnableUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminEnableUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminEnableUser), arg0)
+}
+
+// AdminEnableUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminEnableUserRequest(arg0 *cognitoidentityprovider.AdminEnableUserInput) (*request.Request, *cognitoidentityprovider.AdminEnableUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminEnableUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminEnableUserOutput)
+	return ret0, ret1
+}
+
+// AdminEnableUserRequest indicates an expected call of AdminEnableUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminEnableUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminEnableUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminEnableUserRequest), arg0)
+}
+
+// AdminEnableUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminEnableUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminEnableUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminEnableUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminEnableUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminEnableUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminEnableUserWithContext indicates an expected call of AdminEnableUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminEnableUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminEnableUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminEnableUserWithContext), varargs...)
+}
+
+// AdminForgetDevice mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminForgetDevice(arg0 *cognitoidentityprovider.AdminForgetDeviceInput) (*cognitoidentityprovider.AdminForgetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminForgetDevice", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminForgetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminForgetDevice indicates an expected call of AdminForgetDevice.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminForgetDevice(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminForgetDevice", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminForgetDevice), arg0)
+}
+
+// AdminForgetDeviceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminForgetDeviceRequest(arg0 *cognitoidentityprovider.AdminForgetDeviceInput) (*request.Request, *cognitoidentityprovider.AdminForgetDeviceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminForgetDeviceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminForgetDeviceOutput)
+	return ret0, ret1
+}
+
+// AdminForgetDeviceRequest indicates an expected call of AdminForgetDeviceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminForgetDeviceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminForgetDeviceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminForgetDeviceRequest), arg0)
+}
+
+// AdminForgetDeviceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminForgetDeviceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminForgetDeviceInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminForgetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminForgetDeviceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminForgetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminForgetDeviceWithContext indicates an expected call of AdminForgetDeviceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminForgetDeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminForgetDeviceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminForgetDeviceWithContext), varargs...)
+}
+
+// AdminGetDevice mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminGetDevice(arg0 *cognitoidentityprovider.AdminGetDeviceInput) (*cognitoidentityprovider.AdminGetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminGetDevice", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminGetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminGetDevice indicates an expected call of AdminGetDevice.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminGetDevice(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminGetDevice", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminGetDevice), arg0)
+}
+
+// AdminGetDeviceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminGetDeviceRequest(arg0 *cognitoidentityprovider.AdminGetDeviceInput) (*request.Request, *cognitoidentityprovider.AdminGetDeviceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminGetDeviceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminGetDeviceOutput)
+	return ret0, ret1
+}
+
+// AdminGetDeviceRequest indicates an expected call of AdminGetDeviceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminGetDeviceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminGetDeviceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminGetDeviceRequest), arg0)
+}
+
+// AdminGetDeviceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminGetDeviceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminGetDeviceInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminGetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminGetDeviceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminGetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminGetDeviceWithContext indicates an expected call of AdminGetDeviceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminGetDeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminGetDeviceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminGetDeviceWithContext), varargs...)
+}
+
+// AdminGetUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminGetUser(arg0 *cognitoidentityprovider.AdminGetUserInput) (*cognitoidentityprovider.AdminGetUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminGetUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminGetUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminGetUser indicates an expected call of AdminGetUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminGetUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminGetUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminGetUser), arg0)
+}
+
+// AdminGetUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminGetUserRequest(arg0 *cognitoidentityprovider.AdminGetUserInput) (*request.Request, *cognitoidentityprovider.AdminGetUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminGetUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminGetUserOutput)
+	return ret0, ret1
+}
+
+// AdminGetUserRequest indicates an expected call of AdminGetUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminGetUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminGetUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminGetUserRequest), arg0)
+}
+
+// AdminGetUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminGetUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminGetUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminGetUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminGetUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminGetUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminGetUserWithContext indicates an expected call of AdminGetUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminGetUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminGetUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminGetUserWithContext), varargs...)
+}
+
+// AdminInitiateAuth mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminInitiateAuth(arg0 *cognitoidentityprovider.AdminInitiateAuthInput) (*cognitoidentityprovider.AdminInitiateAuthOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminInitiateAuth", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminInitiateAuthOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminInitiateAuth indicates an expected call of AdminInitiateAuth.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminInitiateAuth(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminInitiateAuth", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminInitiateAuth), arg0)
+}
+
+// AdminInitiateAuthRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminInitiateAuthRequest(arg0 *cognitoidentityprovider.AdminInitiateAuthInput) (*request.Request, *cognitoidentityprovider.AdminInitiateAuthOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminInitiateAuthRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminInitiateAuthOutput)
+	return ret0, ret1
+}
+
+// AdminInitiateAuthRequest indicates an expected call of AdminInitiateAuthRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminInitiateAuthRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminInitiateAuthRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminInitiateAuthRequest), arg0)
+}
+
+// AdminInitiateAuthWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminInitiateAuthWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminInitiateAuthInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminInitiateAuthOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminInitiateAuthWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminInitiateAuthOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminInitiateAuthWithContext indicates an expected call of AdminInitiateAuthWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminInitiateAuthWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminInitiateAuthWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminInitiateAuthWithContext), varargs...)
+}
+
+// AdminLinkProviderForUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminLinkProviderForUser(arg0 *cognitoidentityprovider.AdminLinkProviderForUserInput) (*cognitoidentityprovider.AdminLinkProviderForUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminLinkProviderForUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminLinkProviderForUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminLinkProviderForUser indicates an expected call of AdminLinkProviderForUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminLinkProviderForUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminLinkProviderForUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminLinkProviderForUser), arg0)
+}
+
+// AdminLinkProviderForUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminLinkProviderForUserRequest(arg0 *cognitoidentityprovider.AdminLinkProviderForUserInput) (*request.Request, *cognitoidentityprovider.AdminLinkProviderForUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminLinkProviderForUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminLinkProviderForUserOutput)
+	return ret0, ret1
+}
+
+// AdminLinkProviderForUserRequest indicates an expected call of AdminLinkProviderForUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminLinkProviderForUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminLinkProviderForUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminLinkProviderForUserRequest), arg0)
+}
+
+// AdminLinkProviderForUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminLinkProviderForUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminLinkProviderForUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminLinkProviderForUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminLinkProviderForUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminLinkProviderForUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminLinkProviderForUserWithContext indicates an expected call of AdminLinkProviderForUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminLinkProviderForUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminLinkProviderForUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminLinkProviderForUserWithContext), varargs...)
+}
+
+// AdminListDevices mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListDevices(arg0 *cognitoidentityprovider.AdminListDevicesInput) (*cognitoidentityprovider.AdminListDevicesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListDevices", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminListDevicesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminListDevices indicates an expected call of AdminListDevices.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListDevices(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListDevices", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListDevices), arg0)
+}
+
+// AdminListDevicesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListDevicesRequest(arg0 *cognitoidentityprovider.AdminListDevicesInput) (*request.Request, *cognitoidentityprovider.AdminListDevicesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListDevicesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminListDevicesOutput)
+	return ret0, ret1
+}
+
+// AdminListDevicesRequest indicates an expected call of AdminListDevicesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListDevicesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListDevicesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListDevicesRequest), arg0)
+}
+
+// AdminListDevicesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListDevicesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminListDevicesInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminListDevicesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminListDevicesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminListDevicesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminListDevicesWithContext indicates an expected call of AdminListDevicesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListDevicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListDevicesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListDevicesWithContext), varargs...)
+}
+
+// AdminListGroupsForUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListGroupsForUser(arg0 *cognitoidentityprovider.AdminListGroupsForUserInput) (*cognitoidentityprovider.AdminListGroupsForUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListGroupsForUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminListGroupsForUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminListGroupsForUser indicates an expected call of AdminListGroupsForUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListGroupsForUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListGroupsForUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListGroupsForUser), arg0)
+}
+
+// AdminListGroupsForUserPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListGroupsForUserPages(arg0 *cognitoidentityprovider.AdminListGroupsForUserInput, arg1 func(*cognitoidentityprovider.AdminListGroupsForUserOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListGroupsForUserPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AdminListGroupsForUserPages indicates an expected call of AdminListGroupsForUserPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListGroupsForUserPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListGroupsForUserPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListGroupsForUserPages), arg0, arg1)
+}
+
+// AdminListGroupsForUserPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListGroupsForUserPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminListGroupsForUserInput, arg2 func(*cognitoidentityprovider.AdminListGroupsForUserOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminListGroupsForUserPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AdminListGroupsForUserPagesWithContext indicates an expected call of AdminListGroupsForUserPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListGroupsForUserPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListGroupsForUserPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListGroupsForUserPagesWithContext), varargs...)
+}
+
+// AdminListGroupsForUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListGroupsForUserRequest(arg0 *cognitoidentityprovider.AdminListGroupsForUserInput) (*request.Request, *cognitoidentityprovider.AdminListGroupsForUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListGroupsForUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminListGroupsForUserOutput)
+	return ret0, ret1
+}
+
+// AdminListGroupsForUserRequest indicates an expected call of AdminListGroupsForUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListGroupsForUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListGroupsForUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListGroupsForUserRequest), arg0)
+}
+
+// AdminListGroupsForUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListGroupsForUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminListGroupsForUserInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminListGroupsForUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminListGroupsForUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminListGroupsForUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminListGroupsForUserWithContext indicates an expected call of AdminListGroupsForUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListGroupsForUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListGroupsForUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListGroupsForUserWithContext), varargs...)
+}
+
+// AdminListUserAuthEvents mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListUserAuthEvents(arg0 *cognitoidentityprovider.AdminListUserAuthEventsInput) (*cognitoidentityprovider.AdminListUserAuthEventsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListUserAuthEvents", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminListUserAuthEventsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminListUserAuthEvents indicates an expected call of AdminListUserAuthEvents.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListUserAuthEvents(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListUserAuthEvents", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListUserAuthEvents), arg0)
+}
+
+// AdminListUserAuthEventsPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListUserAuthEventsPages(arg0 *cognitoidentityprovider.AdminListUserAuthEventsInput, arg1 func(*cognitoidentityprovider.AdminListUserAuthEventsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListUserAuthEventsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AdminListUserAuthEventsPages indicates an expected call of AdminListUserAuthEventsPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListUserAuthEventsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListUserAuthEventsPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListUserAuthEventsPages), arg0, arg1)
+}
+
+// AdminListUserAuthEventsPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListUserAuthEventsPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminListUserAuthEventsInput, arg2 func(*cognitoidentityprovider.AdminListUserAuthEventsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminListUserAuthEventsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AdminListUserAuthEventsPagesWithContext indicates an expected call of AdminListUserAuthEventsPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListUserAuthEventsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListUserAuthEventsPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListUserAuthEventsPagesWithContext), varargs...)
+}
+
+// AdminListUserAuthEventsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListUserAuthEventsRequest(arg0 *cognitoidentityprovider.AdminListUserAuthEventsInput) (*request.Request, *cognitoidentityprovider.AdminListUserAuthEventsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminListUserAuthEventsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminListUserAuthEventsOutput)
+	return ret0, ret1
+}
+
+// AdminListUserAuthEventsRequest indicates an expected call of AdminListUserAuthEventsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListUserAuthEventsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListUserAuthEventsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListUserAuthEventsRequest), arg0)
+}
+
+// AdminListUserAuthEventsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminListUserAuthEventsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminListUserAuthEventsInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminListUserAuthEventsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminListUserAuthEventsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminListUserAuthEventsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminListUserAuthEventsWithContext indicates an expected call of AdminListUserAuthEventsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminListUserAuthEventsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminListUserAuthEventsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminListUserAuthEventsWithContext), varargs...)
+}
+
+// AdminRemoveUserFromGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminRemoveUserFromGroup(arg0 *cognitoidentityprovider.AdminRemoveUserFromGroupInput) (*cognitoidentityprovider.AdminRemoveUserFromGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminRemoveUserFromGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminRemoveUserFromGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminRemoveUserFromGroup indicates an expected call of AdminRemoveUserFromGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminRemoveUserFromGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRemoveUserFromGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminRemoveUserFromGroup), arg0)
+}
+
+// AdminRemoveUserFromGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminRemoveUserFromGroupRequest(arg0 *cognitoidentityprovider.AdminRemoveUserFromGroupInput) (*request.Request, *cognitoidentityprovider.AdminRemoveUserFromGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminRemoveUserFromGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminRemoveUserFromGroupOutput)
+	return ret0, ret1
+}
+
+// AdminRemoveUserFromGroupRequest indicates an expected call of AdminRemoveUserFromGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminRemoveUserFromGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRemoveUserFromGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminRemoveUserFromGroupRequest), arg0)
+}
+
+// AdminRemoveUserFromGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminRemoveUserFromGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminRemoveUserFromGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminRemoveUserFromGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminRemoveUserFromGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminRemoveUserFromGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminRemoveUserFromGroupWithContext indicates an expected call of AdminRemoveUserFromGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminRemoveUserFromGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRemoveUserFromGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminRemoveUserFromGroupWithContext), varargs...)
+}
+
+// AdminResetUserPassword mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminResetUserPassword(arg0 *cognitoidentityprovider.AdminResetUserPasswordInput) (*cognitoidentityprovider.AdminResetUserPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminResetUserPassword", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminResetUserPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminResetUserPassword indicates an expected call of AdminResetUserPassword.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminResetUserPassword(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminResetUserPassword", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminResetUserPassword), arg0)
+}
+
+// AdminResetUserPasswordRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminResetUserPasswordRequest(arg0 *cognitoidentityprovider.AdminResetUserPasswordInput) (*request.Request, *cognitoidentityprovider.AdminResetUserPasswordOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminResetUserPasswordRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminResetUserPasswordOutput)
+	return ret0, ret1
+}
+
+// AdminResetUserPasswordRequest indicates an expected call of AdminResetUserPasswordRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminResetUserPasswordRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminResetUserPasswordRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminResetUserPasswordRequest), arg0)
+}
+
+// AdminResetUserPasswordWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminResetUserPasswordWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminResetUserPasswordInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminResetUserPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminResetUserPasswordWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminResetUserPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminResetUserPasswordWithContext indicates an expected call of AdminResetUserPasswordWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminResetUserPasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminResetUserPasswordWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminResetUserPasswordWithContext), varargs...)
+}
+
+// AdminRespondToAuthChallenge mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminRespondToAuthChallenge(arg0 *cognitoidentityprovider.AdminRespondToAuthChallengeInput) (*cognitoidentityprovider.AdminRespondToAuthChallengeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminRespondToAuthChallenge", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminRespondToAuthChallengeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminRespondToAuthChallenge indicates an expected call of AdminRespondToAuthChallenge.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminRespondToAuthChallenge(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRespondToAuthChallenge", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminRespondToAuthChallenge), arg0)
+}
+
+// AdminRespondToAuthChallengeRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminRespondToAuthChallengeRequest(arg0 *cognitoidentityprovider.AdminRespondToAuthChallengeInput) (*request.Request, *cognitoidentityprovider.AdminRespondToAuthChallengeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminRespondToAuthChallengeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminRespondToAuthChallengeOutput)
+	return ret0, ret1
+}
+
+// AdminRespondToAuthChallengeRequest indicates an expected call of AdminRespondToAuthChallengeRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminRespondToAuthChallengeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRespondToAuthChallengeRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminRespondToAuthChallengeRequest), arg0)
+}
+
+// AdminRespondToAuthChallengeWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminRespondToAuthChallengeWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminRespondToAuthChallengeInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminRespondToAuthChallengeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminRespondToAuthChallengeWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminRespondToAuthChallengeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminRespondToAuthChallengeWithContext indicates an expected call of AdminRespondToAuthChallengeWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminRespondToAuthChallengeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminRespondToAuthChallengeWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminRespondToAuthChallengeWithContext), varargs...)
+}
+
+// AdminSetUserMFAPreference mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserMFAPreference(arg0 *cognitoidentityprovider.AdminSetUserMFAPreferenceInput) (*cognitoidentityprovider.AdminSetUserMFAPreferenceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminSetUserMFAPreference", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminSetUserMFAPreferenceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminSetUserMFAPreference indicates an expected call of AdminSetUserMFAPreference.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserMFAPreference(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserMFAPreference", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserMFAPreference), arg0)
+}
+
+// AdminSetUserMFAPreferenceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserMFAPreferenceRequest(arg0 *cognitoidentityprovider.AdminSetUserMFAPreferenceInput) (*request.Request, *cognitoidentityprovider.AdminSetUserMFAPreferenceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminSetUserMFAPreferenceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminSetUserMFAPreferenceOutput)
+	return ret0, ret1
+}
+
+// AdminSetUserMFAPreferenceRequest indicates an expected call of AdminSetUserMFAPreferenceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserMFAPreferenceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserMFAPreferenceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserMFAPreferenceRequest), arg0)
+}
+
+// AdminSetUserMFAPreferenceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserMFAPreferenceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminSetUserMFAPreferenceInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminSetUserMFAPreferenceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminSetUserMFAPreferenceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminSetUserMFAPreferenceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminSetUserMFAPreferenceWithContext indicates an expected call of AdminSetUserMFAPreferenceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserMFAPreferenceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserMFAPreferenceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserMFAPreferenceWithContext), varargs...)
+}
+
+// AdminSetUserPassword mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserPassword(arg0 *cognitoidentityprovider.AdminSetUserPasswordInput) (*cognitoidentityprovider.AdminSetUserPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminSetUserPassword", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminSetUserPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminSetUserPassword indicates an expected call of AdminSetUserPassword.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserPassword(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserPassword", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserPassword), arg0)
+}
+
+// AdminSetUserPasswordRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserPasswordRequest(arg0 *cognitoidentityprovider.AdminSetUserPasswordInput) (*request.Request, *cognitoidentityprovider.AdminSetUserPasswordOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminSetUserPasswordRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminSetUserPasswordOutput)
+	return ret0, ret1
+}
+
+// AdminSetUserPasswordRequest indicates an expected call of AdminSetUserPasswordRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserPasswordRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserPasswordRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserPasswordRequest), arg0)
+}
+
+// AdminSetUserPasswordWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserPasswordWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminSetUserPasswordInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminSetUserPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminSetUserPasswordWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminSetUserPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminSetUserPasswordWithContext indicates an expected call of AdminSetUserPasswordWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserPasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserPasswordWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserPasswordWithContext), varargs...)
+}
+
+// AdminSetUserSettings mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserSettings(arg0 *cognitoidentityprovider.AdminSetUserSettingsInput) (*cognitoidentityprovider.AdminSetUserSettingsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminSetUserSettings", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminSetUserSettingsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminSetUserSettings indicates an expected call of AdminSetUserSettings.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserSettings(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserSettings", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserSettings), arg0)
+}
+
+// AdminSetUserSettingsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserSettingsRequest(arg0 *cognitoidentityprovider.AdminSetUserSettingsInput) (*request.Request, *cognitoidentityprovider.AdminSetUserSettingsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminSetUserSettingsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminSetUserSettingsOutput)
+	return ret0, ret1
+}
+
+// AdminSetUserSettingsRequest indicates an expected call of AdminSetUserSettingsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserSettingsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserSettingsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserSettingsRequest), arg0)
+}
+
+// AdminSetUserSettingsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminSetUserSettingsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminSetUserSettingsInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminSetUserSettingsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminSetUserSettingsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminSetUserSettingsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminSetUserSettingsWithContext indicates an expected call of AdminSetUserSettingsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminSetUserSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminSetUserSettingsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminSetUserSettingsWithContext), varargs...)
+}
+
+// AdminUpdateAuthEventFeedback mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateAuthEventFeedback(arg0 *cognitoidentityprovider.AdminUpdateAuthEventFeedbackInput) (*cognitoidentityprovider.AdminUpdateAuthEventFeedbackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUpdateAuthEventFeedback", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUpdateAuthEventFeedbackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUpdateAuthEventFeedback indicates an expected call of AdminUpdateAuthEventFeedback.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateAuthEventFeedback(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateAuthEventFeedback", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateAuthEventFeedback), arg0)
+}
+
+// AdminUpdateAuthEventFeedbackRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateAuthEventFeedbackRequest(arg0 *cognitoidentityprovider.AdminUpdateAuthEventFeedbackInput) (*request.Request, *cognitoidentityprovider.AdminUpdateAuthEventFeedbackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUpdateAuthEventFeedbackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminUpdateAuthEventFeedbackOutput)
+	return ret0, ret1
+}
+
+// AdminUpdateAuthEventFeedbackRequest indicates an expected call of AdminUpdateAuthEventFeedbackRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateAuthEventFeedbackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateAuthEventFeedbackRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateAuthEventFeedbackRequest), arg0)
+}
+
+// AdminUpdateAuthEventFeedbackWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateAuthEventFeedbackWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminUpdateAuthEventFeedbackInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminUpdateAuthEventFeedbackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminUpdateAuthEventFeedbackWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUpdateAuthEventFeedbackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUpdateAuthEventFeedbackWithContext indicates an expected call of AdminUpdateAuthEventFeedbackWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateAuthEventFeedbackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateAuthEventFeedbackWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateAuthEventFeedbackWithContext), varargs...)
+}
+
+// AdminUpdateDeviceStatus mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateDeviceStatus(arg0 *cognitoidentityprovider.AdminUpdateDeviceStatusInput) (*cognitoidentityprovider.AdminUpdateDeviceStatusOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUpdateDeviceStatus", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUpdateDeviceStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUpdateDeviceStatus indicates an expected call of AdminUpdateDeviceStatus.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateDeviceStatus(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateDeviceStatus", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateDeviceStatus), arg0)
+}
+
+// AdminUpdateDeviceStatusRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateDeviceStatusRequest(arg0 *cognitoidentityprovider.AdminUpdateDeviceStatusInput) (*request.Request, *cognitoidentityprovider.AdminUpdateDeviceStatusOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUpdateDeviceStatusRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminUpdateDeviceStatusOutput)
+	return ret0, ret1
+}
+
+// AdminUpdateDeviceStatusRequest indicates an expected call of AdminUpdateDeviceStatusRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateDeviceStatusRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateDeviceStatusRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateDeviceStatusRequest), arg0)
+}
+
+// AdminUpdateDeviceStatusWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateDeviceStatusWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminUpdateDeviceStatusInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminUpdateDeviceStatusOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminUpdateDeviceStatusWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUpdateDeviceStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUpdateDeviceStatusWithContext indicates an expected call of AdminUpdateDeviceStatusWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateDeviceStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateDeviceStatusWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateDeviceStatusWithContext), varargs...)
+}
+
+// AdminUpdateUserAttributes mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateUserAttributes(arg0 *cognitoidentityprovider.AdminUpdateUserAttributesInput) (*cognitoidentityprovider.AdminUpdateUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUpdateUserAttributes", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUpdateUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUpdateUserAttributes indicates an expected call of AdminUpdateUserAttributes.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateUserAttributes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateUserAttributes", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateUserAttributes), arg0)
+}
+
+// AdminUpdateUserAttributesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateUserAttributesRequest(arg0 *cognitoidentityprovider.AdminUpdateUserAttributesInput) (*request.Request, *cognitoidentityprovider.AdminUpdateUserAttributesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUpdateUserAttributesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminUpdateUserAttributesOutput)
+	return ret0, ret1
+}
+
+// AdminUpdateUserAttributesRequest indicates an expected call of AdminUpdateUserAttributesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateUserAttributesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateUserAttributesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateUserAttributesRequest), arg0)
+}
+
+// AdminUpdateUserAttributesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUpdateUserAttributesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminUpdateUserAttributesInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminUpdateUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminUpdateUserAttributesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUpdateUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUpdateUserAttributesWithContext indicates an expected call of AdminUpdateUserAttributesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUpdateUserAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUpdateUserAttributesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUpdateUserAttributesWithContext), varargs...)
+}
+
+// AdminUserGlobalSignOut mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUserGlobalSignOut(arg0 *cognitoidentityprovider.AdminUserGlobalSignOutInput) (*cognitoidentityprovider.AdminUserGlobalSignOutOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUserGlobalSignOut", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUserGlobalSignOutOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUserGlobalSignOut indicates an expected call of AdminUserGlobalSignOut.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUserGlobalSignOut(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUserGlobalSignOut", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUserGlobalSignOut), arg0)
+}
+
+// AdminUserGlobalSignOutRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUserGlobalSignOutRequest(arg0 *cognitoidentityprovider.AdminUserGlobalSignOutInput) (*request.Request, *cognitoidentityprovider.AdminUserGlobalSignOutOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AdminUserGlobalSignOutRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AdminUserGlobalSignOutOutput)
+	return ret0, ret1
+}
+
+// AdminUserGlobalSignOutRequest indicates an expected call of AdminUserGlobalSignOutRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUserGlobalSignOutRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUserGlobalSignOutRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUserGlobalSignOutRequest), arg0)
+}
+
+// AdminUserGlobalSignOutWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AdminUserGlobalSignOutWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AdminUserGlobalSignOutInput, arg2 ...request.Option) (*cognitoidentityprovider.AdminUserGlobalSignOutOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AdminUserGlobalSignOutWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AdminUserGlobalSignOutOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AdminUserGlobalSignOutWithContext indicates an expected call of AdminUserGlobalSignOutWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AdminUserGlobalSignOutWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdminUserGlobalSignOutWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AdminUserGlobalSignOutWithContext), varargs...)
+}
+
+// AssociateSoftwareToken mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AssociateSoftwareToken(arg0 *cognitoidentityprovider.AssociateSoftwareTokenInput) (*cognitoidentityprovider.AssociateSoftwareTokenOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AssociateSoftwareToken", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AssociateSoftwareTokenOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AssociateSoftwareToken indicates an expected call of AssociateSoftwareToken.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AssociateSoftwareToken(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSoftwareToken", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AssociateSoftwareToken), arg0)
+}
+
+// AssociateSoftwareTokenRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AssociateSoftwareTokenRequest(arg0 *cognitoidentityprovider.AssociateSoftwareTokenInput) (*request.Request, *cognitoidentityprovider.AssociateSoftwareTokenOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AssociateSoftwareTokenRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.AssociateSoftwareTokenOutput)
+	return ret0, ret1
+}
+
+// AssociateSoftwareTokenRequest indicates an expected call of AssociateSoftwareTokenRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AssociateSoftwareTokenRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSoftwareTokenRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AssociateSoftwareTokenRequest), arg0)
+}
+
+// AssociateSoftwareTokenWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) AssociateSoftwareTokenWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.AssociateSoftwareTokenInput, arg2 ...request.Option) (*cognitoidentityprovider.AssociateSoftwareTokenOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "AssociateSoftwareTokenWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.AssociateSoftwareTokenOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AssociateSoftwareTokenWithContext indicates an expected call of AssociateSoftwareTokenWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) AssociateSoftwareTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSoftwareTokenWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).AssociateSoftwareTokenWithContext), varargs...)
+}
+
+// ChangePassword mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ChangePassword(arg0 *cognitoidentityprovider.ChangePasswordInput) (*cognitoidentityprovider.ChangePasswordOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangePassword", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ChangePasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ChangePassword indicates an expected call of ChangePassword.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ChangePassword(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePassword", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ChangePassword), arg0)
+}
+
+// ChangePasswordRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ChangePasswordRequest(arg0 *cognitoidentityprovider.ChangePasswordInput) (*request.Request, *cognitoidentityprovider.ChangePasswordOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ChangePasswordRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ChangePasswordOutput)
+	return ret0, ret1
+}
+
+// ChangePasswordRequest indicates an expected call of ChangePasswordRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ChangePasswordRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePasswordRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ChangePasswordRequest), arg0)
+}
+
+// ChangePasswordWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ChangePasswordWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ChangePasswordInput, arg2 ...request.Option) (*cognitoidentityprovider.ChangePasswordOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ChangePasswordWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ChangePasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ChangePasswordWithContext indicates an expected call of ChangePasswordWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ChangePasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChangePasswordWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ChangePasswordWithContext), varargs...)
+}
+
+// ConfirmDevice mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmDevice(arg0 *cognitoidentityprovider.ConfirmDeviceInput) (*cognitoidentityprovider.ConfirmDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfirmDevice", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ConfirmDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ConfirmDevice indicates an expected call of ConfirmDevice.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmDevice(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmDevice", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmDevice), arg0)
+}
+
+// ConfirmDeviceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmDeviceRequest(arg0 *cognitoidentityprovider.ConfirmDeviceInput) (*request.Request, *cognitoidentityprovider.ConfirmDeviceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfirmDeviceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ConfirmDeviceOutput)
+	return ret0, ret1
+}
+
+// ConfirmDeviceRequest indicates an expected call of ConfirmDeviceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmDeviceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmDeviceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmDeviceRequest), arg0)
+}
+
+// ConfirmDeviceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmDeviceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ConfirmDeviceInput, arg2 ...request.Option) (*cognitoidentityprovider.ConfirmDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ConfirmDeviceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ConfirmDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ConfirmDeviceWithContext indicates an expected call of ConfirmDeviceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmDeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmDeviceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmDeviceWithContext), varargs...)
+}
+
+// ConfirmForgotPassword mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmForgotPassword(arg0 *cognitoidentityprovider.ConfirmForgotPasswordInput) (*cognitoidentityprovider.ConfirmForgotPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfirmForgotPassword", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ConfirmForgotPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ConfirmForgotPassword indicates an expected call of ConfirmForgotPassword.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmForgotPassword(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmForgotPassword", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmForgotPassword), arg0)
+}
+
+// ConfirmForgotPasswordRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmForgotPasswordRequest(arg0 *cognitoidentityprovider.ConfirmForgotPasswordInput) (*request.Request, *cognitoidentityprovider.ConfirmForgotPasswordOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfirmForgotPasswordRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ConfirmForgotPasswordOutput)
+	return ret0, ret1
+}
+
+// ConfirmForgotPasswordRequest indicates an expected call of ConfirmForgotPasswordRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmForgotPasswordRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmForgotPasswordRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmForgotPasswordRequest), arg0)
+}
+
+// ConfirmForgotPasswordWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmForgotPasswordWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ConfirmForgotPasswordInput, arg2 ...request.Option) (*cognitoidentityprovider.ConfirmForgotPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ConfirmForgotPasswordWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ConfirmForgotPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ConfirmForgotPasswordWithContext indicates an expected call of ConfirmForgotPasswordWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmForgotPasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmForgotPasswordWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmForgotPasswordWithContext), varargs...)
+}
+
+// ConfirmSignUp mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmSignUp(arg0 *cognitoidentityprovider.ConfirmSignUpInput) (*cognitoidentityprovider.ConfirmSignUpOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfirmSignUp", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ConfirmSignUpOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ConfirmSignUp indicates an expected call of ConfirmSignUp.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmSignUp(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSignUp", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmSignUp), arg0)
+}
+
+// ConfirmSignUpRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmSignUpRequest(arg0 *cognitoidentityprovider.ConfirmSignUpInput) (*request.Request, *cognitoidentityprovider.ConfirmSignUpOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConfirmSignUpRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ConfirmSignUpOutput)
+	return ret0, ret1
+}
+
+// ConfirmSignUpRequest indicates an expected call of ConfirmSignUpRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmSignUpRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSignUpRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmSignUpRequest), arg0)
+}
+
+// ConfirmSignUpWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ConfirmSignUpWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ConfirmSignUpInput, arg2 ...request.Option) (*cognitoidentityprovider.ConfirmSignUpOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ConfirmSignUpWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ConfirmSignUpOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ConfirmSignUpWithContext indicates an expected call of ConfirmSignUpWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ConfirmSignUpWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmSignUpWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ConfirmSignUpWithContext), varargs...)
+}
+
+// CreateGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateGroup(arg0 *cognitoidentityprovider.CreateGroupInput) (*cognitoidentityprovider.CreateGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateGroup indicates an expected call of CreateGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateGroup), arg0)
+}
+
+// CreateGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateGroupRequest(arg0 *cognitoidentityprovider.CreateGroupInput) (*request.Request, *cognitoidentityprovider.CreateGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateGroupOutput)
+	return ret0, ret1
+}
+
+// CreateGroupRequest indicates an expected call of CreateGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateGroupRequest), arg0)
+}
+
+// CreateGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateGroupWithContext indicates an expected call of CreateGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateGroupWithContext), varargs...)
+}
+
+// CreateIdentityProvider mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateIdentityProvider(arg0 *cognitoidentityprovider.CreateIdentityProviderInput) (*cognitoidentityprovider.CreateIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateIdentityProvider", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateIdentityProvider indicates an expected call of CreateIdentityProvider.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateIdentityProvider(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIdentityProvider", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateIdentityProvider), arg0)
+}
+
+// CreateIdentityProviderRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateIdentityProviderRequest(arg0 *cognitoidentityprovider.CreateIdentityProviderInput) (*request.Request, *cognitoidentityprovider.CreateIdentityProviderOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateIdentityProviderRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateIdentityProviderOutput)
+	return ret0, ret1
+}
+
+// CreateIdentityProviderRequest indicates an expected call of CreateIdentityProviderRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateIdentityProviderRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIdentityProviderRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateIdentityProviderRequest), arg0)
+}
+
+// CreateIdentityProviderWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateIdentityProviderWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateIdentityProviderInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateIdentityProviderWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateIdentityProviderWithContext indicates an expected call of CreateIdentityProviderWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateIdentityProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIdentityProviderWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateIdentityProviderWithContext), varargs...)
+}
+
+// CreateResourceServer mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateResourceServer(arg0 *cognitoidentityprovider.CreateResourceServerInput) (*cognitoidentityprovider.CreateResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateResourceServer", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateResourceServer indicates an expected call of CreateResourceServer.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateResourceServer(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceServer", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateResourceServer), arg0)
+}
+
+// CreateResourceServerRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateResourceServerRequest(arg0 *cognitoidentityprovider.CreateResourceServerInput) (*request.Request, *cognitoidentityprovider.CreateResourceServerOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateResourceServerRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateResourceServerOutput)
+	return ret0, ret1
+}
+
+// CreateResourceServerRequest indicates an expected call of CreateResourceServerRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateResourceServerRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceServerRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateResourceServerRequest), arg0)
+}
+
+// CreateResourceServerWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateResourceServerWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateResourceServerInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateResourceServerWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateResourceServerWithContext indicates an expected call of CreateResourceServerWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateResourceServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateResourceServerWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateResourceServerWithContext), varargs...)
+}
+
+// CreateUserImportJob mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserImportJob(arg0 *cognitoidentityprovider.CreateUserImportJobInput) (*cognitoidentityprovider.CreateUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserImportJob", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserImportJob indicates an expected call of CreateUserImportJob.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserImportJob(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserImportJob", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserImportJob), arg0)
+}
+
+// CreateUserImportJobRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserImportJobRequest(arg0 *cognitoidentityprovider.CreateUserImportJobInput) (*request.Request, *cognitoidentityprovider.CreateUserImportJobOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserImportJobRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateUserImportJobOutput)
+	return ret0, ret1
+}
+
+// CreateUserImportJobRequest indicates an expected call of CreateUserImportJobRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserImportJobRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserImportJobRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserImportJobRequest), arg0)
+}
+
+// CreateUserImportJobWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserImportJobWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateUserImportJobInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateUserImportJobWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserImportJobWithContext indicates an expected call of CreateUserImportJobWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserImportJobWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserImportJobWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserImportJobWithContext), varargs...)
+}
+
+// CreateUserPool mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPool(arg0 *cognitoidentityprovider.CreateUserPoolInput) (*cognitoidentityprovider.CreateUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserPool", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserPool indicates an expected call of CreateUserPool.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPool(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPool", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPool), arg0)
+}
+
+// CreateUserPoolClient mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolClient(arg0 *cognitoidentityprovider.CreateUserPoolClientInput) (*cognitoidentityprovider.CreateUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserPoolClient", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserPoolClient indicates an expected call of CreateUserPoolClient.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolClient(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolClient", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolClient), arg0)
+}
+
+// CreateUserPoolClientRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolClientRequest(arg0 *cognitoidentityprovider.CreateUserPoolClientInput) (*request.Request, *cognitoidentityprovider.CreateUserPoolClientOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserPoolClientRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateUserPoolClientOutput)
+	return ret0, ret1
+}
+
+// CreateUserPoolClientRequest indicates an expected call of CreateUserPoolClientRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolClientRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolClientRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolClientRequest), arg0)
+}
+
+// CreateUserPoolClientWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolClientWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateUserPoolClientInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateUserPoolClientWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserPoolClientWithContext indicates an expected call of CreateUserPoolClientWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolClientWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolClientWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolClientWithContext), varargs...)
+}
+
+// CreateUserPoolDomain mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolDomain(arg0 *cognitoidentityprovider.CreateUserPoolDomainInput) (*cognitoidentityprovider.CreateUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserPoolDomain", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserPoolDomain indicates an expected call of CreateUserPoolDomain.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolDomain(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolDomain", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolDomain), arg0)
+}
+
+// CreateUserPoolDomainRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolDomainRequest(arg0 *cognitoidentityprovider.CreateUserPoolDomainInput) (*request.Request, *cognitoidentityprovider.CreateUserPoolDomainOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserPoolDomainRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateUserPoolDomainOutput)
+	return ret0, ret1
+}
+
+// CreateUserPoolDomainRequest indicates an expected call of CreateUserPoolDomainRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolDomainRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolDomainRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolDomainRequest), arg0)
+}
+
+// CreateUserPoolDomainWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolDomainWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateUserPoolDomainInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateUserPoolDomainWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserPoolDomainWithContext indicates an expected call of CreateUserPoolDomainWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolDomainWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolDomainWithContext), varargs...)
+}
+
+// CreateUserPoolRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolRequest(arg0 *cognitoidentityprovider.CreateUserPoolInput) (*request.Request, *cognitoidentityprovider.CreateUserPoolOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateUserPoolRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.CreateUserPoolOutput)
+	return ret0, ret1
+}
+
+// CreateUserPoolRequest indicates an expected call of CreateUserPoolRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolRequest), arg0)
+}
+
+// CreateUserPoolWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) CreateUserPoolWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.CreateUserPoolInput, arg2 ...request.Option) (*cognitoidentityprovider.CreateUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateUserPoolWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.CreateUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateUserPoolWithContext indicates an expected call of CreateUserPoolWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) CreateUserPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateUserPoolWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).CreateUserPoolWithContext), varargs...)
+}
+
+// DeleteGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteGroup(arg0 *cognitoidentityprovider.DeleteGroupInput) (*cognitoidentityprovider.DeleteGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteGroup indicates an expected call of DeleteGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteGroup), arg0)
+}
+
+// DeleteGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteGroupRequest(arg0 *cognitoidentityprovider.DeleteGroupInput) (*request.Request, *cognitoidentityprovider.DeleteGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteGroupOutput)
+	return ret0, ret1
+}
+
+// DeleteGroupRequest indicates an expected call of DeleteGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteGroupRequest), arg0)
+}
+
+// DeleteGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteGroupWithContext indicates an expected call of DeleteGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteGroupWithContext), varargs...)
+}
+
+// DeleteIdentityProvider mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteIdentityProvider(arg0 *cognitoidentityprovider.DeleteIdentityProviderInput) (*cognitoidentityprovider.DeleteIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteIdentityProvider", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteIdentityProvider indicates an expected call of DeleteIdentityProvider.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteIdentityProvider(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIdentityProvider", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteIdentityProvider), arg0)
+}
+
+// DeleteIdentityProviderRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteIdentityProviderRequest(arg0 *cognitoidentityprovider.DeleteIdentityProviderInput) (*request.Request, *cognitoidentityprovider.DeleteIdentityProviderOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteIdentityProviderRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteIdentityProviderOutput)
+	return ret0, ret1
+}
+
+// DeleteIdentityProviderRequest indicates an expected call of DeleteIdentityProviderRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteIdentityProviderRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIdentityProviderRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteIdentityProviderRequest), arg0)
+}
+
+// DeleteIdentityProviderWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteIdentityProviderWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteIdentityProviderInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteIdentityProviderWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteIdentityProviderWithContext indicates an expected call of DeleteIdentityProviderWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteIdentityProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIdentityProviderWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteIdentityProviderWithContext), varargs...)
+}
+
+// DeleteResourceServer mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteResourceServer(arg0 *cognitoidentityprovider.DeleteResourceServerInput) (*cognitoidentityprovider.DeleteResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteResourceServer", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteResourceServer indicates an expected call of DeleteResourceServer.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteResourceServer(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceServer", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteResourceServer), arg0)
+}
+
+// DeleteResourceServerRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteResourceServerRequest(arg0 *cognitoidentityprovider.DeleteResourceServerInput) (*request.Request, *cognitoidentityprovider.DeleteResourceServerOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteResourceServerRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteResourceServerOutput)
+	return ret0, ret1
+}
+
+// DeleteResourceServerRequest indicates an expected call of DeleteResourceServerRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteResourceServerRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceServerRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteResourceServerRequest), arg0)
+}
+
+// DeleteResourceServerWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteResourceServerWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteResourceServerInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteResourceServerWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteResourceServerWithContext indicates an expected call of DeleteResourceServerWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteResourceServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteResourceServerWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteResourceServerWithContext), varargs...)
+}
+
+// DeleteUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUser(arg0 *cognitoidentityprovider.DeleteUserInput) (*cognitoidentityprovider.DeleteUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUser indicates an expected call of DeleteUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUser), arg0)
+}
+
+// DeleteUserAttributes mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserAttributes(arg0 *cognitoidentityprovider.DeleteUserAttributesInput) (*cognitoidentityprovider.DeleteUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserAttributes", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserAttributes indicates an expected call of DeleteUserAttributes.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserAttributes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserAttributes", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserAttributes), arg0)
+}
+
+// DeleteUserAttributesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserAttributesRequest(arg0 *cognitoidentityprovider.DeleteUserAttributesInput) (*request.Request, *cognitoidentityprovider.DeleteUserAttributesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserAttributesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteUserAttributesOutput)
+	return ret0, ret1
+}
+
+// DeleteUserAttributesRequest indicates an expected call of DeleteUserAttributesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserAttributesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserAttributesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserAttributesRequest), arg0)
+}
+
+// DeleteUserAttributesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserAttributesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteUserAttributesInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteUserAttributesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserAttributesWithContext indicates an expected call of DeleteUserAttributesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserAttributesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserAttributesWithContext), varargs...)
+}
+
+// DeleteUserPool mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPool(arg0 *cognitoidentityprovider.DeleteUserPoolInput) (*cognitoidentityprovider.DeleteUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserPool", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserPool indicates an expected call of DeleteUserPool.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPool(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPool", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPool), arg0)
+}
+
+// DeleteUserPoolClient mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolClient(arg0 *cognitoidentityprovider.DeleteUserPoolClientInput) (*cognitoidentityprovider.DeleteUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserPoolClient", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserPoolClient indicates an expected call of DeleteUserPoolClient.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolClient(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolClient", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolClient), arg0)
+}
+
+// DeleteUserPoolClientRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolClientRequest(arg0 *cognitoidentityprovider.DeleteUserPoolClientInput) (*request.Request, *cognitoidentityprovider.DeleteUserPoolClientOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserPoolClientRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteUserPoolClientOutput)
+	return ret0, ret1
+}
+
+// DeleteUserPoolClientRequest indicates an expected call of DeleteUserPoolClientRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolClientRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolClientRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolClientRequest), arg0)
+}
+
+// DeleteUserPoolClientWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolClientWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteUserPoolClientInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteUserPoolClientWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserPoolClientWithContext indicates an expected call of DeleteUserPoolClientWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolClientWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolClientWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolClientWithContext), varargs...)
+}
+
+// DeleteUserPoolDomain mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolDomain(arg0 *cognitoidentityprovider.DeleteUserPoolDomainInput) (*cognitoidentityprovider.DeleteUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserPoolDomain", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserPoolDomain indicates an expected call of DeleteUserPoolDomain.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolDomain(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolDomain", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolDomain), arg0)
+}
+
+// DeleteUserPoolDomainRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolDomainRequest(arg0 *cognitoidentityprovider.DeleteUserPoolDomainInput) (*request.Request, *cognitoidentityprovider.DeleteUserPoolDomainOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserPoolDomainRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteUserPoolDomainOutput)
+	return ret0, ret1
+}
+
+// DeleteUserPoolDomainRequest indicates an expected call of DeleteUserPoolDomainRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolDomainRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolDomainRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolDomainRequest), arg0)
+}
+
+// DeleteUserPoolDomainWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolDomainWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteUserPoolDomainInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteUserPoolDomainWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserPoolDomainWithContext indicates an expected call of DeleteUserPoolDomainWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolDomainWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolDomainWithContext), varargs...)
+}
+
+// DeleteUserPoolRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolRequest(arg0 *cognitoidentityprovider.DeleteUserPoolInput) (*request.Request, *cognitoidentityprovider.DeleteUserPoolOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserPoolRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteUserPoolOutput)
+	return ret0, ret1
+}
+
+// DeleteUserPoolRequest indicates an expected call of DeleteUserPoolRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolRequest), arg0)
+}
+
+// DeleteUserPoolWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserPoolWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteUserPoolInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteUserPoolWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserPoolWithContext indicates an expected call of DeleteUserPoolWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserPoolWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserPoolWithContext), varargs...)
+}
+
+// DeleteUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserRequest(arg0 *cognitoidentityprovider.DeleteUserInput) (*request.Request, *cognitoidentityprovider.DeleteUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DeleteUserOutput)
+	return ret0, ret1
+}
+
+// DeleteUserRequest indicates an expected call of DeleteUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserRequest), arg0)
+}
+
+// DeleteUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DeleteUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DeleteUserInput, arg2 ...request.Option) (*cognitoidentityprovider.DeleteUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DeleteUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteUserWithContext indicates an expected call of DeleteUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DeleteUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DeleteUserWithContext), varargs...)
+}
+
+// DescribeIdentityProvider mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeIdentityProvider(arg0 *cognitoidentityprovider.DescribeIdentityProviderInput) (*cognitoidentityprovider.DescribeIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeIdentityProvider", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeIdentityProvider indicates an expected call of DescribeIdentityProvider.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeIdentityProvider(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityProvider", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeIdentityProvider), arg0)
+}
+
+// DescribeIdentityProviderRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeIdentityProviderRequest(arg0 *cognitoidentityprovider.DescribeIdentityProviderInput) (*request.Request, *cognitoidentityprovider.DescribeIdentityProviderOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeIdentityProviderRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeIdentityProviderOutput)
+	return ret0, ret1
+}
+
+// DescribeIdentityProviderRequest indicates an expected call of DescribeIdentityProviderRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeIdentityProviderRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityProviderRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeIdentityProviderRequest), arg0)
+}
+
+// DescribeIdentityProviderWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeIdentityProviderWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeIdentityProviderInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeIdentityProviderWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeIdentityProviderWithContext indicates an expected call of DescribeIdentityProviderWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeIdentityProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityProviderWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeIdentityProviderWithContext), varargs...)
+}
+
+// DescribeResourceServer mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeResourceServer(arg0 *cognitoidentityprovider.DescribeResourceServerInput) (*cognitoidentityprovider.DescribeResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeResourceServer", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeResourceServer indicates an expected call of DescribeResourceServer.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeResourceServer(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceServer", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeResourceServer), arg0)
+}
+
+// DescribeResourceServerRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeResourceServerRequest(arg0 *cognitoidentityprovider.DescribeResourceServerInput) (*request.Request, *cognitoidentityprovider.DescribeResourceServerOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeResourceServerRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeResourceServerOutput)
+	return ret0, ret1
+}
+
+// DescribeResourceServerRequest indicates an expected call of DescribeResourceServerRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeResourceServerRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceServerRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeResourceServerRequest), arg0)
+}
+
+// DescribeResourceServerWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeResourceServerWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeResourceServerInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeResourceServerWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeResourceServerWithContext indicates an expected call of DescribeResourceServerWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeResourceServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeResourceServerWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeResourceServerWithContext), varargs...)
+}
+
+// DescribeRiskConfiguration mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeRiskConfiguration(arg0 *cognitoidentityprovider.DescribeRiskConfigurationInput) (*cognitoidentityprovider.DescribeRiskConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeRiskConfiguration", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeRiskConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeRiskConfiguration indicates an expected call of DescribeRiskConfiguration.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeRiskConfiguration(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRiskConfiguration", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeRiskConfiguration), arg0)
+}
+
+// DescribeRiskConfigurationRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeRiskConfigurationRequest(arg0 *cognitoidentityprovider.DescribeRiskConfigurationInput) (*request.Request, *cognitoidentityprovider.DescribeRiskConfigurationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeRiskConfigurationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeRiskConfigurationOutput)
+	return ret0, ret1
+}
+
+// DescribeRiskConfigurationRequest indicates an expected call of DescribeRiskConfigurationRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeRiskConfigurationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRiskConfigurationRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeRiskConfigurationRequest), arg0)
+}
+
+// DescribeRiskConfigurationWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeRiskConfigurationWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeRiskConfigurationInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeRiskConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeRiskConfigurationWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeRiskConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeRiskConfigurationWithContext indicates an expected call of DescribeRiskConfigurationWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeRiskConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRiskConfigurationWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeRiskConfigurationWithContext), varargs...)
+}
+
+// DescribeUserImportJob mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserImportJob(arg0 *cognitoidentityprovider.DescribeUserImportJobInput) (*cognitoidentityprovider.DescribeUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserImportJob", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserImportJob indicates an expected call of DescribeUserImportJob.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserImportJob(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserImportJob", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserImportJob), arg0)
+}
+
+// DescribeUserImportJobRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserImportJobRequest(arg0 *cognitoidentityprovider.DescribeUserImportJobInput) (*request.Request, *cognitoidentityprovider.DescribeUserImportJobOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserImportJobRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeUserImportJobOutput)
+	return ret0, ret1
+}
+
+// DescribeUserImportJobRequest indicates an expected call of DescribeUserImportJobRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserImportJobRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserImportJobRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserImportJobRequest), arg0)
+}
+
+// DescribeUserImportJobWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserImportJobWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeUserImportJobInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeUserImportJobWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserImportJobWithContext indicates an expected call of DescribeUserImportJobWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserImportJobWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserImportJobWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserImportJobWithContext), varargs...)
+}
+
+// DescribeUserPool mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPool(arg0 *cognitoidentityprovider.DescribeUserPoolInput) (*cognitoidentityprovider.DescribeUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserPool", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserPool indicates an expected call of DescribeUserPool.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPool(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPool", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPool), arg0)
+}
+
+// DescribeUserPoolClient mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolClient(arg0 *cognitoidentityprovider.DescribeUserPoolClientInput) (*cognitoidentityprovider.DescribeUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserPoolClient", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserPoolClient indicates an expected call of DescribeUserPoolClient.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolClient(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolClient", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolClient), arg0)
+}
+
+// DescribeUserPoolClientRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolClientRequest(arg0 *cognitoidentityprovider.DescribeUserPoolClientInput) (*request.Request, *cognitoidentityprovider.DescribeUserPoolClientOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserPoolClientRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeUserPoolClientOutput)
+	return ret0, ret1
+}
+
+// DescribeUserPoolClientRequest indicates an expected call of DescribeUserPoolClientRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolClientRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolClientRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolClientRequest), arg0)
+}
+
+// DescribeUserPoolClientWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolClientWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeUserPoolClientInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeUserPoolClientWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserPoolClientWithContext indicates an expected call of DescribeUserPoolClientWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolClientWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolClientWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolClientWithContext), varargs...)
+}
+
+// DescribeUserPoolDomain mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolDomain(arg0 *cognitoidentityprovider.DescribeUserPoolDomainInput) (*cognitoidentityprovider.DescribeUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserPoolDomain", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserPoolDomain indicates an expected call of DescribeUserPoolDomain.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolDomain(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolDomain", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolDomain), arg0)
+}
+
+// DescribeUserPoolDomainRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolDomainRequest(arg0 *cognitoidentityprovider.DescribeUserPoolDomainInput) (*request.Request, *cognitoidentityprovider.DescribeUserPoolDomainOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserPoolDomainRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeUserPoolDomainOutput)
+	return ret0, ret1
+}
+
+// DescribeUserPoolDomainRequest indicates an expected call of DescribeUserPoolDomainRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolDomainRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolDomainRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolDomainRequest), arg0)
+}
+
+// DescribeUserPoolDomainWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolDomainWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeUserPoolDomainInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeUserPoolDomainWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserPoolDomainWithContext indicates an expected call of DescribeUserPoolDomainWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolDomainWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolDomainWithContext), varargs...)
+}
+
+// DescribeUserPoolRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolRequest(arg0 *cognitoidentityprovider.DescribeUserPoolInput) (*request.Request, *cognitoidentityprovider.DescribeUserPoolOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DescribeUserPoolRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.DescribeUserPoolOutput)
+	return ret0, ret1
+}
+
+// DescribeUserPoolRequest indicates an expected call of DescribeUserPoolRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolRequest), arg0)
+}
+
+// DescribeUserPoolWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) DescribeUserPoolWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.DescribeUserPoolInput, arg2 ...request.Option) (*cognitoidentityprovider.DescribeUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DescribeUserPoolWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.DescribeUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DescribeUserPoolWithContext indicates an expected call of DescribeUserPoolWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) DescribeUserPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeUserPoolWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).DescribeUserPoolWithContext), varargs...)
+}
+
+// ForgetDevice mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ForgetDevice(arg0 *cognitoidentityprovider.ForgetDeviceInput) (*cognitoidentityprovider.ForgetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForgetDevice", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ForgetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ForgetDevice indicates an expected call of ForgetDevice.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ForgetDevice(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForgetDevice", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ForgetDevice), arg0)
+}
+
+// ForgetDeviceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ForgetDeviceRequest(arg0 *cognitoidentityprovider.ForgetDeviceInput) (*request.Request, *cognitoidentityprovider.ForgetDeviceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForgetDeviceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ForgetDeviceOutput)
+	return ret0, ret1
+}
+
+// ForgetDeviceRequest indicates an expected call of ForgetDeviceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ForgetDeviceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForgetDeviceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ForgetDeviceRequest), arg0)
+}
+
+// ForgetDeviceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ForgetDeviceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ForgetDeviceInput, arg2 ...request.Option) (*cognitoidentityprovider.ForgetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ForgetDeviceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ForgetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ForgetDeviceWithContext indicates an expected call of ForgetDeviceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ForgetDeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForgetDeviceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ForgetDeviceWithContext), varargs...)
+}
+
+// ForgotPassword mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ForgotPassword(arg0 *cognitoidentityprovider.ForgotPasswordInput) (*cognitoidentityprovider.ForgotPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForgotPassword", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ForgotPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ForgotPassword indicates an expected call of ForgotPassword.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ForgotPassword(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForgotPassword", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ForgotPassword), arg0)
+}
+
+// ForgotPasswordRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ForgotPasswordRequest(arg0 *cognitoidentityprovider.ForgotPasswordInput) (*request.Request, *cognitoidentityprovider.ForgotPasswordOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ForgotPasswordRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ForgotPasswordOutput)
+	return ret0, ret1
+}
+
+// ForgotPasswordRequest indicates an expected call of ForgotPasswordRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ForgotPasswordRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForgotPasswordRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ForgotPasswordRequest), arg0)
+}
+
+// ForgotPasswordWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ForgotPasswordWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ForgotPasswordInput, arg2 ...request.Option) (*cognitoidentityprovider.ForgotPasswordOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ForgotPasswordWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ForgotPasswordOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ForgotPasswordWithContext indicates an expected call of ForgotPasswordWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ForgotPasswordWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForgotPasswordWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ForgotPasswordWithContext), varargs...)
+}
+
+// GetCSVHeader mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetCSVHeader(arg0 *cognitoidentityprovider.GetCSVHeaderInput) (*cognitoidentityprovider.GetCSVHeaderOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCSVHeader", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetCSVHeaderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCSVHeader indicates an expected call of GetCSVHeader.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetCSVHeader(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCSVHeader", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetCSVHeader), arg0)
+}
+
+// GetCSVHeaderRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetCSVHeaderRequest(arg0 *cognitoidentityprovider.GetCSVHeaderInput) (*request.Request, *cognitoidentityprovider.GetCSVHeaderOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCSVHeaderRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetCSVHeaderOutput)
+	return ret0, ret1
+}
+
+// GetCSVHeaderRequest indicates an expected call of GetCSVHeaderRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetCSVHeaderRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCSVHeaderRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetCSVHeaderRequest), arg0)
+}
+
+// GetCSVHeaderWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetCSVHeaderWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetCSVHeaderInput, arg2 ...request.Option) (*cognitoidentityprovider.GetCSVHeaderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCSVHeaderWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetCSVHeaderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCSVHeaderWithContext indicates an expected call of GetCSVHeaderWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetCSVHeaderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCSVHeaderWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetCSVHeaderWithContext), varargs...)
+}
+
+// GetDevice mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetDevice(arg0 *cognitoidentityprovider.GetDeviceInput) (*cognitoidentityprovider.GetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDevice", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDevice indicates an expected call of GetDevice.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetDevice(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDevice", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetDevice), arg0)
+}
+
+// GetDeviceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetDeviceRequest(arg0 *cognitoidentityprovider.GetDeviceInput) (*request.Request, *cognitoidentityprovider.GetDeviceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDeviceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetDeviceOutput)
+	return ret0, ret1
+}
+
+// GetDeviceRequest indicates an expected call of GetDeviceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetDeviceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetDeviceRequest), arg0)
+}
+
+// GetDeviceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetDeviceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetDeviceInput, arg2 ...request.Option) (*cognitoidentityprovider.GetDeviceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetDeviceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetDeviceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDeviceWithContext indicates an expected call of GetDeviceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetDeviceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeviceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetDeviceWithContext), varargs...)
+}
+
+// GetGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetGroup(arg0 *cognitoidentityprovider.GetGroupInput) (*cognitoidentityprovider.GetGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGroup indicates an expected call of GetGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetGroup), arg0)
+}
+
+// GetGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetGroupRequest(arg0 *cognitoidentityprovider.GetGroupInput) (*request.Request, *cognitoidentityprovider.GetGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetGroupOutput)
+	return ret0, ret1
+}
+
+// GetGroupRequest indicates an expected call of GetGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetGroupRequest), arg0)
+}
+
+// GetGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.GetGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetGroupWithContext indicates an expected call of GetGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetGroupWithContext), varargs...)
+}
+
+// GetIdentityProviderByIdentifier mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetIdentityProviderByIdentifier(arg0 *cognitoidentityprovider.GetIdentityProviderByIdentifierInput) (*cognitoidentityprovider.GetIdentityProviderByIdentifierOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetIdentityProviderByIdentifier", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetIdentityProviderByIdentifierOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIdentityProviderByIdentifier indicates an expected call of GetIdentityProviderByIdentifier.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetIdentityProviderByIdentifier(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIdentityProviderByIdentifier", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetIdentityProviderByIdentifier), arg0)
+}
+
+// GetIdentityProviderByIdentifierRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetIdentityProviderByIdentifierRequest(arg0 *cognitoidentityprovider.GetIdentityProviderByIdentifierInput) (*request.Request, *cognitoidentityprovider.GetIdentityProviderByIdentifierOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetIdentityProviderByIdentifierRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetIdentityProviderByIdentifierOutput)
+	return ret0, ret1
+}
+
+// GetIdentityProviderByIdentifierRequest indicates an expected call of GetIdentityProviderByIdentifierRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetIdentityProviderByIdentifierRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIdentityProviderByIdentifierRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetIdentityProviderByIdentifierRequest), arg0)
+}
+
+// GetIdentityProviderByIdentifierWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetIdentityProviderByIdentifierWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetIdentityProviderByIdentifierInput, arg2 ...request.Option) (*cognitoidentityprovider.GetIdentityProviderByIdentifierOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetIdentityProviderByIdentifierWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetIdentityProviderByIdentifierOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetIdentityProviderByIdentifierWithContext indicates an expected call of GetIdentityProviderByIdentifierWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetIdentityProviderByIdentifierWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIdentityProviderByIdentifierWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetIdentityProviderByIdentifierWithContext), varargs...)
+}
+
+// GetLogDeliveryConfiguration mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetLogDeliveryConfiguration(arg0 *cognitoidentityprovider.GetLogDeliveryConfigurationInput) (*cognitoidentityprovider.GetLogDeliveryConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLogDeliveryConfiguration", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetLogDeliveryConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLogDeliveryConfiguration indicates an expected call of GetLogDeliveryConfiguration.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetLogDeliveryConfiguration(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogDeliveryConfiguration", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetLogDeliveryConfiguration), arg0)
+}
+
+// GetLogDeliveryConfigurationRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetLogDeliveryConfigurationRequest(arg0 *cognitoidentityprovider.GetLogDeliveryConfigurationInput) (*request.Request, *cognitoidentityprovider.GetLogDeliveryConfigurationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetLogDeliveryConfigurationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetLogDeliveryConfigurationOutput)
+	return ret0, ret1
+}
+
+// GetLogDeliveryConfigurationRequest indicates an expected call of GetLogDeliveryConfigurationRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetLogDeliveryConfigurationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogDeliveryConfigurationRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetLogDeliveryConfigurationRequest), arg0)
+}
+
+// GetLogDeliveryConfigurationWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetLogDeliveryConfigurationWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetLogDeliveryConfigurationInput, arg2 ...request.Option) (*cognitoidentityprovider.GetLogDeliveryConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetLogDeliveryConfigurationWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetLogDeliveryConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetLogDeliveryConfigurationWithContext indicates an expected call of GetLogDeliveryConfigurationWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetLogDeliveryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLogDeliveryConfigurationWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetLogDeliveryConfigurationWithContext), varargs...)
+}
+
+// GetSigningCertificate mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetSigningCertificate(arg0 *cognitoidentityprovider.GetSigningCertificateInput) (*cognitoidentityprovider.GetSigningCertificateOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSigningCertificate", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetSigningCertificateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSigningCertificate indicates an expected call of GetSigningCertificate.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetSigningCertificate(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSigningCertificate", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetSigningCertificate), arg0)
+}
+
+// GetSigningCertificateRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetSigningCertificateRequest(arg0 *cognitoidentityprovider.GetSigningCertificateInput) (*request.Request, *cognitoidentityprovider.GetSigningCertificateOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSigningCertificateRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetSigningCertificateOutput)
+	return ret0, ret1
+}
+
+// GetSigningCertificateRequest indicates an expected call of GetSigningCertificateRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetSigningCertificateRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSigningCertificateRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetSigningCertificateRequest), arg0)
+}
+
+// GetSigningCertificateWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetSigningCertificateWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetSigningCertificateInput, arg2 ...request.Option) (*cognitoidentityprovider.GetSigningCertificateOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetSigningCertificateWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetSigningCertificateOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSigningCertificateWithContext indicates an expected call of GetSigningCertificateWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetSigningCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSigningCertificateWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetSigningCertificateWithContext), varargs...)
+}
+
+// GetUICustomization mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUICustomization(arg0 *cognitoidentityprovider.GetUICustomizationInput) (*cognitoidentityprovider.GetUICustomizationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUICustomization", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUICustomizationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUICustomization indicates an expected call of GetUICustomization.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUICustomization(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUICustomization", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUICustomization), arg0)
+}
+
+// GetUICustomizationRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUICustomizationRequest(arg0 *cognitoidentityprovider.GetUICustomizationInput) (*request.Request, *cognitoidentityprovider.GetUICustomizationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUICustomizationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetUICustomizationOutput)
+	return ret0, ret1
+}
+
+// GetUICustomizationRequest indicates an expected call of GetUICustomizationRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUICustomizationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUICustomizationRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUICustomizationRequest), arg0)
+}
+
+// GetUICustomizationWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUICustomizationWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetUICustomizationInput, arg2 ...request.Option) (*cognitoidentityprovider.GetUICustomizationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUICustomizationWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUICustomizationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUICustomizationWithContext indicates an expected call of GetUICustomizationWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUICustomizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUICustomizationWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUICustomizationWithContext), varargs...)
+}
+
+// GetUser mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUser(arg0 *cognitoidentityprovider.GetUserInput) (*cognitoidentityprovider.GetUserOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUser", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUser indicates an expected call of GetUser.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUser(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUser", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUser), arg0)
+}
+
+// GetUserAttributeVerificationCode mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserAttributeVerificationCode(arg0 *cognitoidentityprovider.GetUserAttributeVerificationCodeInput) (*cognitoidentityprovider.GetUserAttributeVerificationCodeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserAttributeVerificationCode", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUserAttributeVerificationCodeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserAttributeVerificationCode indicates an expected call of GetUserAttributeVerificationCode.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserAttributeVerificationCode(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAttributeVerificationCode", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserAttributeVerificationCode), arg0)
+}
+
+// GetUserAttributeVerificationCodeRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserAttributeVerificationCodeRequest(arg0 *cognitoidentityprovider.GetUserAttributeVerificationCodeInput) (*request.Request, *cognitoidentityprovider.GetUserAttributeVerificationCodeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserAttributeVerificationCodeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetUserAttributeVerificationCodeOutput)
+	return ret0, ret1
+}
+
+// GetUserAttributeVerificationCodeRequest indicates an expected call of GetUserAttributeVerificationCodeRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserAttributeVerificationCodeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAttributeVerificationCodeRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserAttributeVerificationCodeRequest), arg0)
+}
+
+// GetUserAttributeVerificationCodeWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserAttributeVerificationCodeWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetUserAttributeVerificationCodeInput, arg2 ...request.Option) (*cognitoidentityprovider.GetUserAttributeVerificationCodeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUserAttributeVerificationCodeWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUserAttributeVerificationCodeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserAttributeVerificationCodeWithContext indicates an expected call of GetUserAttributeVerificationCodeWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserAttributeVerificationCodeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserAttributeVerificationCodeWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserAttributeVerificationCodeWithContext), varargs...)
+}
+
+// GetUserPoolMfaConfig mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserPoolMfaConfig(arg0 *cognitoidentityprovider.GetUserPoolMfaConfigInput) (*cognitoidentityprovider.GetUserPoolMfaConfigOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserPoolMfaConfig", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUserPoolMfaConfigOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserPoolMfaConfig indicates an expected call of GetUserPoolMfaConfig.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserPoolMfaConfig(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPoolMfaConfig", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserPoolMfaConfig), arg0)
+}
+
+// GetUserPoolMfaConfigRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserPoolMfaConfigRequest(arg0 *cognitoidentityprovider.GetUserPoolMfaConfigInput) (*request.Request, *cognitoidentityprovider.GetUserPoolMfaConfigOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserPoolMfaConfigRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetUserPoolMfaConfigOutput)
+	return ret0, ret1
+}
+
+// GetUserPoolMfaConfigRequest indicates an expected call of GetUserPoolMfaConfigRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserPoolMfaConfigRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPoolMfaConfigRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserPoolMfaConfigRequest), arg0)
+}
+
+// GetUserPoolMfaConfigWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserPoolMfaConfigWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetUserPoolMfaConfigInput, arg2 ...request.Option) (*cognitoidentityprovider.GetUserPoolMfaConfigOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUserPoolMfaConfigWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUserPoolMfaConfigOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserPoolMfaConfigWithContext indicates an expected call of GetUserPoolMfaConfigWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserPoolMfaConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserPoolMfaConfigWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserPoolMfaConfigWithContext), varargs...)
+}
+
+// GetUserRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserRequest(arg0 *cognitoidentityprovider.GetUserInput) (*request.Request, *cognitoidentityprovider.GetUserOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GetUserOutput)
+	return ret0, ret1
+}
+
+// GetUserRequest indicates an expected call of GetUserRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserRequest), arg0)
+}
+
+// GetUserWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GetUserWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GetUserInput, arg2 ...request.Option) (*cognitoidentityprovider.GetUserOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUserWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GetUserOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserWithContext indicates an expected call of GetUserWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GetUserWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GetUserWithContext), varargs...)
+}
+
+// GlobalSignOut mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GlobalSignOut(arg0 *cognitoidentityprovider.GlobalSignOutInput) (*cognitoidentityprovider.GlobalSignOutOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GlobalSignOut", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GlobalSignOutOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GlobalSignOut indicates an expected call of GlobalSignOut.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GlobalSignOut(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GlobalSignOut", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GlobalSignOut), arg0)
+}
+
+// GlobalSignOutRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GlobalSignOutRequest(arg0 *cognitoidentityprovider.GlobalSignOutInput) (*request.Request, *cognitoidentityprovider.GlobalSignOutOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GlobalSignOutRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.GlobalSignOutOutput)
+	return ret0, ret1
+}
+
+// GlobalSignOutRequest indicates an expected call of GlobalSignOutRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GlobalSignOutRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GlobalSignOutRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GlobalSignOutRequest), arg0)
+}
+
+// GlobalSignOutWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) GlobalSignOutWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.GlobalSignOutInput, arg2 ...request.Option) (*cognitoidentityprovider.GlobalSignOutOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GlobalSignOutWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.GlobalSignOutOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GlobalSignOutWithContext indicates an expected call of GlobalSignOutWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) GlobalSignOutWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GlobalSignOutWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).GlobalSignOutWithContext), varargs...)
+}
+
+// InitiateAuth mocks base method.
+func (m *MockCognitoIdentityProviderAPI) InitiateAuth(arg0 *cognitoidentityprovider.InitiateAuthInput) (*cognitoidentityprovider.InitiateAuthOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InitiateAuth", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.InitiateAuthOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InitiateAuth indicates an expected call of InitiateAuth.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) InitiateAuth(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateAuth", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).InitiateAuth), arg0)
+}
+
+// InitiateAuthRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) InitiateAuthRequest(arg0 *cognitoidentityprovider.InitiateAuthInput) (*request.Request, *cognitoidentityprovider.InitiateAuthOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InitiateAuthRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.InitiateAuthOutput)
+	return ret0, ret1
+}
+
+// InitiateAuthRequest indicates an expected call of InitiateAuthRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) InitiateAuthRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateAuthRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).InitiateAuthRequest), arg0)
+}
+
+// InitiateAuthWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) InitiateAuthWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.InitiateAuthInput, arg2 ...request.Option) (*cognitoidentityprovider.InitiateAuthOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "InitiateAuthWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.InitiateAuthOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InitiateAuthWithContext indicates an expected call of InitiateAuthWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) InitiateAuthWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateAuthWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).InitiateAuthWithContext), varargs...)
+}
+
+// ListDevices mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListDevices(arg0 *cognitoidentityprovider.ListDevicesInput) (*cognitoidentityprovider.ListDevicesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListDevices", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListDevicesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListDevices indicates an expected call of ListDevices.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListDevices(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDevices", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListDevices), arg0)
+}
+
+// ListDevicesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListDevicesRequest(arg0 *cognitoidentityprovider.ListDevicesInput) (*request.Request, *cognitoidentityprovider.ListDevicesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListDevicesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListDevicesOutput)
+	return ret0, ret1
+}
+
+// ListDevicesRequest indicates an expected call of ListDevicesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListDevicesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDevicesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListDevicesRequest), arg0)
+}
+
+// ListDevicesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListDevicesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListDevicesInput, arg2 ...request.Option) (*cognitoidentityprovider.ListDevicesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListDevicesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListDevicesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListDevicesWithContext indicates an expected call of ListDevicesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListDevicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDevicesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListDevicesWithContext), varargs...)
+}
+
+// ListGroups mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListGroups(arg0 *cognitoidentityprovider.ListGroupsInput) (*cognitoidentityprovider.ListGroupsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGroups", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListGroupsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListGroups indicates an expected call of ListGroups.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListGroups(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroups", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListGroups), arg0)
+}
+
+// ListGroupsPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListGroupsPages(arg0 *cognitoidentityprovider.ListGroupsInput, arg1 func(*cognitoidentityprovider.ListGroupsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGroupsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListGroupsPages indicates an expected call of ListGroupsPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListGroupsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListGroupsPages), arg0, arg1)
+}
+
+// ListGroupsPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListGroupsPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListGroupsInput, arg2 func(*cognitoidentityprovider.ListGroupsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListGroupsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListGroupsPagesWithContext indicates an expected call of ListGroupsPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListGroupsPagesWithContext), varargs...)
+}
+
+// ListGroupsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListGroupsRequest(arg0 *cognitoidentityprovider.ListGroupsInput) (*request.Request, *cognitoidentityprovider.ListGroupsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListGroupsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListGroupsOutput)
+	return ret0, ret1
+}
+
+// ListGroupsRequest indicates an expected call of ListGroupsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListGroupsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListGroupsRequest), arg0)
+}
+
+// ListGroupsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListGroupsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListGroupsInput, arg2 ...request.Option) (*cognitoidentityprovider.ListGroupsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListGroupsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListGroupsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListGroupsWithContext indicates an expected call of ListGroupsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListGroupsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListGroupsWithContext), varargs...)
+}
+
+// ListIdentityProviders mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListIdentityProviders(arg0 *cognitoidentityprovider.ListIdentityProvidersInput) (*cognitoidentityprovider.ListIdentityProvidersOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListIdentityProviders", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListIdentityProvidersOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListIdentityProviders indicates an expected call of ListIdentityProviders.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListIdentityProviders(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIdentityProviders", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListIdentityProviders), arg0)
+}
+
+// ListIdentityProvidersPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListIdentityProvidersPages(arg0 *cognitoidentityprovider.ListIdentityProvidersInput, arg1 func(*cognitoidentityprovider.ListIdentityProvidersOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListIdentityProvidersPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListIdentityProvidersPages indicates an expected call of ListIdentityProvidersPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListIdentityProvidersPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIdentityProvidersPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListIdentityProvidersPages), arg0, arg1)
+}
+
+// ListIdentityProvidersPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListIdentityProvidersPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListIdentityProvidersInput, arg2 func(*cognitoidentityprovider.ListIdentityProvidersOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListIdentityProvidersPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListIdentityProvidersPagesWithContext indicates an expected call of ListIdentityProvidersPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListIdentityProvidersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIdentityProvidersPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListIdentityProvidersPagesWithContext), varargs...)
+}
+
+// ListIdentityProvidersRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListIdentityProvidersRequest(arg0 *cognitoidentityprovider.ListIdentityProvidersInput) (*request.Request, *cognitoidentityprovider.ListIdentityProvidersOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListIdentityProvidersRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListIdentityProvidersOutput)
+	return ret0, ret1
+}
+
+// ListIdentityProvidersRequest indicates an expected call of ListIdentityProvidersRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListIdentityProvidersRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIdentityProvidersRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListIdentityProvidersRequest), arg0)
+}
+
+// ListIdentityProvidersWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListIdentityProvidersWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListIdentityProvidersInput, arg2 ...request.Option) (*cognitoidentityprovider.ListIdentityProvidersOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListIdentityProvidersWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListIdentityProvidersOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListIdentityProvidersWithContext indicates an expected call of ListIdentityProvidersWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListIdentityProvidersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIdentityProvidersWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListIdentityProvidersWithContext), varargs...)
+}
+
+// ListResourceServers mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListResourceServers(arg0 *cognitoidentityprovider.ListResourceServersInput) (*cognitoidentityprovider.ListResourceServersOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceServers", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListResourceServersOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceServers indicates an expected call of ListResourceServers.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListResourceServers(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceServers", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListResourceServers), arg0)
+}
+
+// ListResourceServersPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListResourceServersPages(arg0 *cognitoidentityprovider.ListResourceServersInput, arg1 func(*cognitoidentityprovider.ListResourceServersOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceServersPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceServersPages indicates an expected call of ListResourceServersPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListResourceServersPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceServersPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListResourceServersPages), arg0, arg1)
+}
+
+// ListResourceServersPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListResourceServersPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListResourceServersInput, arg2 func(*cognitoidentityprovider.ListResourceServersOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListResourceServersPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListResourceServersPagesWithContext indicates an expected call of ListResourceServersPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListResourceServersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceServersPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListResourceServersPagesWithContext), varargs...)
+}
+
+// ListResourceServersRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListResourceServersRequest(arg0 *cognitoidentityprovider.ListResourceServersInput) (*request.Request, *cognitoidentityprovider.ListResourceServersOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListResourceServersRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListResourceServersOutput)
+	return ret0, ret1
+}
+
+// ListResourceServersRequest indicates an expected call of ListResourceServersRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListResourceServersRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceServersRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListResourceServersRequest), arg0)
+}
+
+// ListResourceServersWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListResourceServersWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListResourceServersInput, arg2 ...request.Option) (*cognitoidentityprovider.ListResourceServersOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListResourceServersWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListResourceServersOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListResourceServersWithContext indicates an expected call of ListResourceServersWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListResourceServersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListResourceServersWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListResourceServersWithContext), varargs...)
+}
+
+// ListTagsForResource mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListTagsForResource(arg0 *cognitoidentityprovider.ListTagsForResourceInput) (*cognitoidentityprovider.ListTagsForResourceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListTagsForResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTagsForResource indicates an expected call of ListTagsForResource.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListTagsForResource(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResource", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListTagsForResource), arg0)
+}
+
+// ListTagsForResourceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListTagsForResourceRequest(arg0 *cognitoidentityprovider.ListTagsForResourceInput) (*request.Request, *cognitoidentityprovider.ListTagsForResourceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListTagsForResourceOutput)
+	return ret0, ret1
+}
+
+// ListTagsForResourceRequest indicates an expected call of ListTagsForResourceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListTagsForResourceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListTagsForResourceRequest), arg0)
+}
+
+// ListTagsForResourceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListTagsForResourceInput, arg2 ...request.Option) (*cognitoidentityprovider.ListTagsForResourceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListTagsForResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListTagsForResourceWithContext indicates an expected call of ListTagsForResourceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListTagsForResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListTagsForResourceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListTagsForResourceWithContext), varargs...)
+}
+
+// ListUserImportJobs mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserImportJobs(arg0 *cognitoidentityprovider.ListUserImportJobsInput) (*cognitoidentityprovider.ListUserImportJobsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserImportJobs", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUserImportJobsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUserImportJobs indicates an expected call of ListUserImportJobs.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserImportJobs(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserImportJobs", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserImportJobs), arg0)
+}
+
+// ListUserImportJobsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserImportJobsRequest(arg0 *cognitoidentityprovider.ListUserImportJobsInput) (*request.Request, *cognitoidentityprovider.ListUserImportJobsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserImportJobsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListUserImportJobsOutput)
+	return ret0, ret1
+}
+
+// ListUserImportJobsRequest indicates an expected call of ListUserImportJobsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserImportJobsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserImportJobsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserImportJobsRequest), arg0)
+}
+
+// ListUserImportJobsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserImportJobsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUserImportJobsInput, arg2 ...request.Option) (*cognitoidentityprovider.ListUserImportJobsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUserImportJobsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUserImportJobsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUserImportJobsWithContext indicates an expected call of ListUserImportJobsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserImportJobsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserImportJobsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserImportJobsWithContext), varargs...)
+}
+
+// ListUserPoolClients mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolClients(arg0 *cognitoidentityprovider.ListUserPoolClientsInput) (*cognitoidentityprovider.ListUserPoolClientsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserPoolClients", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUserPoolClientsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUserPoolClients indicates an expected call of ListUserPoolClients.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolClients(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolClients", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolClients), arg0)
+}
+
+// ListUserPoolClientsPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolClientsPages(arg0 *cognitoidentityprovider.ListUserPoolClientsInput, arg1 func(*cognitoidentityprovider.ListUserPoolClientsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserPoolClientsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUserPoolClientsPages indicates an expected call of ListUserPoolClientsPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolClientsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolClientsPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolClientsPages), arg0, arg1)
+}
+
+// ListUserPoolClientsPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolClientsPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUserPoolClientsInput, arg2 func(*cognitoidentityprovider.ListUserPoolClientsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUserPoolClientsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUserPoolClientsPagesWithContext indicates an expected call of ListUserPoolClientsPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolClientsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolClientsPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolClientsPagesWithContext), varargs...)
+}
+
+// ListUserPoolClientsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolClientsRequest(arg0 *cognitoidentityprovider.ListUserPoolClientsInput) (*request.Request, *cognitoidentityprovider.ListUserPoolClientsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserPoolClientsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListUserPoolClientsOutput)
+	return ret0, ret1
+}
+
+// ListUserPoolClientsRequest indicates an expected call of ListUserPoolClientsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolClientsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolClientsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolClientsRequest), arg0)
+}
+
+// ListUserPoolClientsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolClientsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUserPoolClientsInput, arg2 ...request.Option) (*cognitoidentityprovider.ListUserPoolClientsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUserPoolClientsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUserPoolClientsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUserPoolClientsWithContext indicates an expected call of ListUserPoolClientsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolClientsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolClientsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolClientsWithContext), varargs...)
+}
+
+// ListUserPools mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPools(arg0 *cognitoidentityprovider.ListUserPoolsInput) (*cognitoidentityprovider.ListUserPoolsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserPools", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUserPoolsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUserPools indicates an expected call of ListUserPools.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPools(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPools", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPools), arg0)
+}
+
+// ListUserPoolsPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolsPages(arg0 *cognitoidentityprovider.ListUserPoolsInput, arg1 func(*cognitoidentityprovider.ListUserPoolsOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserPoolsPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUserPoolsPages indicates an expected call of ListUserPoolsPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolsPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolsPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolsPages), arg0, arg1)
+}
+
+// ListUserPoolsPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolsPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUserPoolsInput, arg2 func(*cognitoidentityprovider.ListUserPoolsOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUserPoolsPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUserPoolsPagesWithContext indicates an expected call of ListUserPoolsPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolsPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolsPagesWithContext), varargs...)
+}
+
+// ListUserPoolsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolsRequest(arg0 *cognitoidentityprovider.ListUserPoolsInput) (*request.Request, *cognitoidentityprovider.ListUserPoolsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUserPoolsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListUserPoolsOutput)
+	return ret0, ret1
+}
+
+// ListUserPoolsRequest indicates an expected call of ListUserPoolsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolsRequest), arg0)
+}
+
+// ListUserPoolsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUserPoolsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUserPoolsInput, arg2 ...request.Option) (*cognitoidentityprovider.ListUserPoolsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUserPoolsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUserPoolsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUserPoolsWithContext indicates an expected call of ListUserPoolsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUserPoolsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUserPoolsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUserPoolsWithContext), varargs...)
+}
+
+// ListUsers mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsers(arg0 *cognitoidentityprovider.ListUsersInput) (*cognitoidentityprovider.ListUsersOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUsers", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUsersOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUsers indicates an expected call of ListUsers.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsers(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsers", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsers), arg0)
+}
+
+// ListUsersInGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersInGroup(arg0 *cognitoidentityprovider.ListUsersInGroupInput) (*cognitoidentityprovider.ListUsersInGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUsersInGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUsersInGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUsersInGroup indicates an expected call of ListUsersInGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersInGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersInGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersInGroup), arg0)
+}
+
+// ListUsersInGroupPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersInGroupPages(arg0 *cognitoidentityprovider.ListUsersInGroupInput, arg1 func(*cognitoidentityprovider.ListUsersInGroupOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUsersInGroupPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUsersInGroupPages indicates an expected call of ListUsersInGroupPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersInGroupPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersInGroupPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersInGroupPages), arg0, arg1)
+}
+
+// ListUsersInGroupPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersInGroupPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUsersInGroupInput, arg2 func(*cognitoidentityprovider.ListUsersInGroupOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUsersInGroupPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUsersInGroupPagesWithContext indicates an expected call of ListUsersInGroupPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersInGroupPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersInGroupPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersInGroupPagesWithContext), varargs...)
+}
+
+// ListUsersInGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersInGroupRequest(arg0 *cognitoidentityprovider.ListUsersInGroupInput) (*request.Request, *cognitoidentityprovider.ListUsersInGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUsersInGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListUsersInGroupOutput)
+	return ret0, ret1
+}
+
+// ListUsersInGroupRequest indicates an expected call of ListUsersInGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersInGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersInGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersInGroupRequest), arg0)
+}
+
+// ListUsersInGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersInGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUsersInGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.ListUsersInGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUsersInGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUsersInGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUsersInGroupWithContext indicates an expected call of ListUsersInGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersInGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersInGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersInGroupWithContext), varargs...)
+}
+
+// ListUsersPages mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersPages(arg0 *cognitoidentityprovider.ListUsersInput, arg1 func(*cognitoidentityprovider.ListUsersOutput, bool) bool) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUsersPages", arg0, arg1)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUsersPages indicates an expected call of ListUsersPages.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersPages(arg0, arg1 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersPages", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersPages), arg0, arg1)
+}
+
+// ListUsersPagesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersPagesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUsersInput, arg2 func(*cognitoidentityprovider.ListUsersOutput, bool) bool, arg3 ...request.Option) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1, arg2}
+	for _, a := range arg3 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUsersPagesWithContext", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// ListUsersPagesWithContext indicates an expected call of ListUsersPagesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersPagesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersPagesWithContext), varargs...)
+}
+
+// ListUsersRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersRequest(arg0 *cognitoidentityprovider.ListUsersInput) (*request.Request, *cognitoidentityprovider.ListUsersOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListUsersRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ListUsersOutput)
+	return ret0, ret1
+}
+
+// ListUsersRequest indicates an expected call of ListUsersRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersRequest), arg0)
+}
+
+// ListUsersWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ListUsersWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ListUsersInput, arg2 ...request.Option) (*cognitoidentityprovider.ListUsersOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ListUsersWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ListUsersOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListUsersWithContext indicates an expected call of ListUsersWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ListUsersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListUsersWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ListUsersWithContext), varargs...)
+}
+
+// ResendConfirmationCode mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ResendConfirmationCode(arg0 *cognitoidentityprovider.ResendConfirmationCodeInput) (*cognitoidentityprovider.ResendConfirmationCodeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResendConfirmationCode", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ResendConfirmationCodeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ResendConfirmationCode indicates an expected call of ResendConfirmationCode.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ResendConfirmationCode(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendConfirmationCode", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ResendConfirmationCode), arg0)
+}
+
+// ResendConfirmationCodeRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ResendConfirmationCodeRequest(arg0 *cognitoidentityprovider.ResendConfirmationCodeInput) (*request.Request, *cognitoidentityprovider.ResendConfirmationCodeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ResendConfirmationCodeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.ResendConfirmationCodeOutput)
+	return ret0, ret1
+}
+
+// ResendConfirmationCodeRequest indicates an expected call of ResendConfirmationCodeRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ResendConfirmationCodeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendConfirmationCodeRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ResendConfirmationCodeRequest), arg0)
+}
+
+// ResendConfirmationCodeWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) ResendConfirmationCodeWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.ResendConfirmationCodeInput, arg2 ...request.Option) (*cognitoidentityprovider.ResendConfirmationCodeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ResendConfirmationCodeWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.ResendConfirmationCodeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ResendConfirmationCodeWithContext indicates an expected call of ResendConfirmationCodeWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) ResendConfirmationCodeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResendConfirmationCodeWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).ResendConfirmationCodeWithContext), varargs...)
+}
+
+// RespondToAuthChallenge mocks base method.
+func (m *MockCognitoIdentityProviderAPI) RespondToAuthChallenge(arg0 *cognitoidentityprovider.RespondToAuthChallengeInput) (*cognitoidentityprovider.RespondToAuthChallengeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RespondToAuthChallenge", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.RespondToAuthChallengeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RespondToAuthChallenge indicates an expected call of RespondToAuthChallenge.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) RespondToAuthChallenge(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondToAuthChallenge", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).RespondToAuthChallenge), arg0)
+}
+
+// RespondToAuthChallengeRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) RespondToAuthChallengeRequest(arg0 *cognitoidentityprovider.RespondToAuthChallengeInput) (*request.Request, *cognitoidentityprovider.RespondToAuthChallengeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RespondToAuthChallengeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.RespondToAuthChallengeOutput)
+	return ret0, ret1
+}
+
+// RespondToAuthChallengeRequest indicates an expected call of RespondToAuthChallengeRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) RespondToAuthChallengeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondToAuthChallengeRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).RespondToAuthChallengeRequest), arg0)
+}
+
+// RespondToAuthChallengeWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) RespondToAuthChallengeWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.RespondToAuthChallengeInput, arg2 ...request.Option) (*cognitoidentityprovider.RespondToAuthChallengeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RespondToAuthChallengeWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.RespondToAuthChallengeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RespondToAuthChallengeWithContext indicates an expected call of RespondToAuthChallengeWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) RespondToAuthChallengeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RespondToAuthChallengeWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).RespondToAuthChallengeWithContext), varargs...)
+}
+
+// RevokeToken mocks base method.
+func (m *MockCognitoIdentityProviderAPI) RevokeToken(arg0 *cognitoidentityprovider.RevokeTokenInput) (*cognitoidentityprovider.RevokeTokenOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RevokeToken", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.RevokeTokenOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RevokeToken indicates an expected call of RevokeToken.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) RevokeToken(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeToken", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).RevokeToken), arg0)
+}
+
+// RevokeTokenRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) RevokeTokenRequest(arg0 *cognitoidentityprovider.RevokeTokenInput) (*request.Request, *cognitoidentityprovider.RevokeTokenOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RevokeTokenRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.RevokeTokenOutput)
+	return ret0, ret1
+}
+
+// RevokeTokenRequest indicates an expected call of RevokeTokenRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) RevokeTokenRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeTokenRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).RevokeTokenRequest), arg0)
+}
+
+// RevokeTokenWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) RevokeTokenWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.RevokeTokenInput, arg2 ...request.Option) (*cognitoidentityprovider.RevokeTokenOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "RevokeTokenWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.RevokeTokenOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// RevokeTokenWithContext indicates an expected call of RevokeTokenWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) RevokeTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeTokenWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).RevokeTokenWithContext), varargs...)
+}
+
+// SetLogDeliveryConfiguration mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetLogDeliveryConfiguration(arg0 *cognitoidentityprovider.SetLogDeliveryConfigurationInput) (*cognitoidentityprovider.SetLogDeliveryConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetLogDeliveryConfiguration", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetLogDeliveryConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetLogDeliveryConfiguration indicates an expected call of SetLogDeliveryConfiguration.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetLogDeliveryConfiguration(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogDeliveryConfiguration", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetLogDeliveryConfiguration), arg0)
+}
+
+// SetLogDeliveryConfigurationRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetLogDeliveryConfigurationRequest(arg0 *cognitoidentityprovider.SetLogDeliveryConfigurationInput) (*request.Request, *cognitoidentityprovider.SetLogDeliveryConfigurationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetLogDeliveryConfigurationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SetLogDeliveryConfigurationOutput)
+	return ret0, ret1
+}
+
+// SetLogDeliveryConfigurationRequest indicates an expected call of SetLogDeliveryConfigurationRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetLogDeliveryConfigurationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogDeliveryConfigurationRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetLogDeliveryConfigurationRequest), arg0)
+}
+
+// SetLogDeliveryConfigurationWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetLogDeliveryConfigurationWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SetLogDeliveryConfigurationInput, arg2 ...request.Option) (*cognitoidentityprovider.SetLogDeliveryConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetLogDeliveryConfigurationWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetLogDeliveryConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetLogDeliveryConfigurationWithContext indicates an expected call of SetLogDeliveryConfigurationWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetLogDeliveryConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLogDeliveryConfigurationWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetLogDeliveryConfigurationWithContext), varargs...)
+}
+
+// SetRiskConfiguration mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetRiskConfiguration(arg0 *cognitoidentityprovider.SetRiskConfigurationInput) (*cognitoidentityprovider.SetRiskConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetRiskConfiguration", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetRiskConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetRiskConfiguration indicates an expected call of SetRiskConfiguration.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetRiskConfiguration(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRiskConfiguration", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetRiskConfiguration), arg0)
+}
+
+// SetRiskConfigurationRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetRiskConfigurationRequest(arg0 *cognitoidentityprovider.SetRiskConfigurationInput) (*request.Request, *cognitoidentityprovider.SetRiskConfigurationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetRiskConfigurationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SetRiskConfigurationOutput)
+	return ret0, ret1
+}
+
+// SetRiskConfigurationRequest indicates an expected call of SetRiskConfigurationRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetRiskConfigurationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRiskConfigurationRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetRiskConfigurationRequest), arg0)
+}
+
+// SetRiskConfigurationWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetRiskConfigurationWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SetRiskConfigurationInput, arg2 ...request.Option) (*cognitoidentityprovider.SetRiskConfigurationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetRiskConfigurationWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetRiskConfigurationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetRiskConfigurationWithContext indicates an expected call of SetRiskConfigurationWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetRiskConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRiskConfigurationWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetRiskConfigurationWithContext), varargs...)
+}
+
+// SetUICustomization mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUICustomization(arg0 *cognitoidentityprovider.SetUICustomizationInput) (*cognitoidentityprovider.SetUICustomizationOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUICustomization", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUICustomizationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUICustomization indicates an expected call of SetUICustomization.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUICustomization(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUICustomization", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUICustomization), arg0)
+}
+
+// SetUICustomizationRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUICustomizationRequest(arg0 *cognitoidentityprovider.SetUICustomizationInput) (*request.Request, *cognitoidentityprovider.SetUICustomizationOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUICustomizationRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SetUICustomizationOutput)
+	return ret0, ret1
+}
+
+// SetUICustomizationRequest indicates an expected call of SetUICustomizationRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUICustomizationRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUICustomizationRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUICustomizationRequest), arg0)
+}
+
+// SetUICustomizationWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUICustomizationWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SetUICustomizationInput, arg2 ...request.Option) (*cognitoidentityprovider.SetUICustomizationOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetUICustomizationWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUICustomizationOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUICustomizationWithContext indicates an expected call of SetUICustomizationWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUICustomizationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUICustomizationWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUICustomizationWithContext), varargs...)
+}
+
+// SetUserMFAPreference mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserMFAPreference(arg0 *cognitoidentityprovider.SetUserMFAPreferenceInput) (*cognitoidentityprovider.SetUserMFAPreferenceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUserMFAPreference", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUserMFAPreferenceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUserMFAPreference indicates an expected call of SetUserMFAPreference.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserMFAPreference(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserMFAPreference", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserMFAPreference), arg0)
+}
+
+// SetUserMFAPreferenceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserMFAPreferenceRequest(arg0 *cognitoidentityprovider.SetUserMFAPreferenceInput) (*request.Request, *cognitoidentityprovider.SetUserMFAPreferenceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUserMFAPreferenceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SetUserMFAPreferenceOutput)
+	return ret0, ret1
+}
+
+// SetUserMFAPreferenceRequest indicates an expected call of SetUserMFAPreferenceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserMFAPreferenceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserMFAPreferenceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserMFAPreferenceRequest), arg0)
+}
+
+// SetUserMFAPreferenceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserMFAPreferenceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SetUserMFAPreferenceInput, arg2 ...request.Option) (*cognitoidentityprovider.SetUserMFAPreferenceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetUserMFAPreferenceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUserMFAPreferenceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUserMFAPreferenceWithContext indicates an expected call of SetUserMFAPreferenceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserMFAPreferenceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserMFAPreferenceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserMFAPreferenceWithContext), varargs...)
+}
+
+// SetUserPoolMfaConfig mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserPoolMfaConfig(arg0 *cognitoidentityprovider.SetUserPoolMfaConfigInput) (*cognitoidentityprovider.SetUserPoolMfaConfigOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUserPoolMfaConfig", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUserPoolMfaConfigOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUserPoolMfaConfig indicates an expected call of SetUserPoolMfaConfig.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserPoolMfaConfig(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserPoolMfaConfig", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserPoolMfaConfig), arg0)
+}
+
+// SetUserPoolMfaConfigRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserPoolMfaConfigRequest(arg0 *cognitoidentityprovider.SetUserPoolMfaConfigInput) (*request.Request, *cognitoidentityprovider.SetUserPoolMfaConfigOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUserPoolMfaConfigRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SetUserPoolMfaConfigOutput)
+	return ret0, ret1
+}
+
+// SetUserPoolMfaConfigRequest indicates an expected call of SetUserPoolMfaConfigRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserPoolMfaConfigRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserPoolMfaConfigRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserPoolMfaConfigRequest), arg0)
+}
+
+// SetUserPoolMfaConfigWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserPoolMfaConfigWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SetUserPoolMfaConfigInput, arg2 ...request.Option) (*cognitoidentityprovider.SetUserPoolMfaConfigOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetUserPoolMfaConfigWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUserPoolMfaConfigOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUserPoolMfaConfigWithContext indicates an expected call of SetUserPoolMfaConfigWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserPoolMfaConfigWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserPoolMfaConfigWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserPoolMfaConfigWithContext), varargs...)
+}
+
+// SetUserSettings mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserSettings(arg0 *cognitoidentityprovider.SetUserSettingsInput) (*cognitoidentityprovider.SetUserSettingsOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUserSettings", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUserSettingsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUserSettings indicates an expected call of SetUserSettings.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserSettings(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserSettings", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserSettings), arg0)
+}
+
+// SetUserSettingsRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserSettingsRequest(arg0 *cognitoidentityprovider.SetUserSettingsInput) (*request.Request, *cognitoidentityprovider.SetUserSettingsOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SetUserSettingsRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SetUserSettingsOutput)
+	return ret0, ret1
+}
+
+// SetUserSettingsRequest indicates an expected call of SetUserSettingsRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserSettingsRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserSettingsRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserSettingsRequest), arg0)
+}
+
+// SetUserSettingsWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SetUserSettingsWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SetUserSettingsInput, arg2 ...request.Option) (*cognitoidentityprovider.SetUserSettingsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SetUserSettingsWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SetUserSettingsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SetUserSettingsWithContext indicates an expected call of SetUserSettingsWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SetUserSettingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetUserSettingsWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SetUserSettingsWithContext), varargs...)
+}
+
+// SignUp mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SignUp(arg0 *cognitoidentityprovider.SignUpInput) (*cognitoidentityprovider.SignUpOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SignUp", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SignUpOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SignUp indicates an expected call of SignUp.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SignUp(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignUp", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SignUp), arg0)
+}
+
+// SignUpRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SignUpRequest(arg0 *cognitoidentityprovider.SignUpInput) (*request.Request, *cognitoidentityprovider.SignUpOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SignUpRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.SignUpOutput)
+	return ret0, ret1
+}
+
+// SignUpRequest indicates an expected call of SignUpRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SignUpRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignUpRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SignUpRequest), arg0)
+}
+
+// SignUpWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) SignUpWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.SignUpInput, arg2 ...request.Option) (*cognitoidentityprovider.SignUpOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "SignUpWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.SignUpOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SignUpWithContext indicates an expected call of SignUpWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) SignUpWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SignUpWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).SignUpWithContext), varargs...)
+}
+
+// StartUserImportJob mocks base method.
+func (m *MockCognitoIdentityProviderAPI) StartUserImportJob(arg0 *cognitoidentityprovider.StartUserImportJobInput) (*cognitoidentityprovider.StartUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartUserImportJob", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.StartUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartUserImportJob indicates an expected call of StartUserImportJob.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) StartUserImportJob(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartUserImportJob", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).StartUserImportJob), arg0)
+}
+
+// StartUserImportJobRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) StartUserImportJobRequest(arg0 *cognitoidentityprovider.StartUserImportJobInput) (*request.Request, *cognitoidentityprovider.StartUserImportJobOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StartUserImportJobRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.StartUserImportJobOutput)
+	return ret0, ret1
+}
+
+// StartUserImportJobRequest indicates an expected call of StartUserImportJobRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) StartUserImportJobRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartUserImportJobRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).StartUserImportJobRequest), arg0)
+}
+
+// StartUserImportJobWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) StartUserImportJobWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.StartUserImportJobInput, arg2 ...request.Option) (*cognitoidentityprovider.StartUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StartUserImportJobWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.StartUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StartUserImportJobWithContext indicates an expected call of StartUserImportJobWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) StartUserImportJobWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartUserImportJobWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).StartUserImportJobWithContext), varargs...)
+}
+
+// StopUserImportJob mocks base method.
+func (m *MockCognitoIdentityProviderAPI) StopUserImportJob(arg0 *cognitoidentityprovider.StopUserImportJobInput) (*cognitoidentityprovider.StopUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StopUserImportJob", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.StopUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StopUserImportJob indicates an expected call of StopUserImportJob.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) StopUserImportJob(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopUserImportJob", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).StopUserImportJob), arg0)
+}
+
+// StopUserImportJobRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) StopUserImportJobRequest(arg0 *cognitoidentityprovider.StopUserImportJobInput) (*request.Request, *cognitoidentityprovider.StopUserImportJobOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StopUserImportJobRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.StopUserImportJobOutput)
+	return ret0, ret1
+}
+
+// StopUserImportJobRequest indicates an expected call of StopUserImportJobRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) StopUserImportJobRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopUserImportJobRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).StopUserImportJobRequest), arg0)
+}
+
+// StopUserImportJobWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) StopUserImportJobWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.StopUserImportJobInput, arg2 ...request.Option) (*cognitoidentityprovider.StopUserImportJobOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "StopUserImportJobWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.StopUserImportJobOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StopUserImportJobWithContext indicates an expected call of StopUserImportJobWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) StopUserImportJobWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopUserImportJobWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).StopUserImportJobWithContext), varargs...)
+}
+
+// TagResource mocks base method.
+func (m *MockCognitoIdentityProviderAPI) TagResource(arg0 *cognitoidentityprovider.TagResourceInput) (*cognitoidentityprovider.TagResourceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TagResource", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.TagResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TagResource indicates an expected call of TagResource.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) TagResource(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResource", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).TagResource), arg0)
+}
+
+// TagResourceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) TagResourceRequest(arg0 *cognitoidentityprovider.TagResourceInput) (*request.Request, *cognitoidentityprovider.TagResourceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.TagResourceOutput)
+	return ret0, ret1
+}
+
+// TagResourceRequest indicates an expected call of TagResourceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) TagResourceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).TagResourceRequest), arg0)
+}
+
+// TagResourceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) TagResourceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.TagResourceInput, arg2 ...request.Option) (*cognitoidentityprovider.TagResourceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.TagResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// TagResourceWithContext indicates an expected call of TagResourceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) TagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TagResourceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).TagResourceWithContext), varargs...)
+}
+
+// UntagResource mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UntagResource(arg0 *cognitoidentityprovider.UntagResourceInput) (*cognitoidentityprovider.UntagResourceOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UntagResource", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UntagResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UntagResource indicates an expected call of UntagResource.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UntagResource(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResource", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UntagResource), arg0)
+}
+
+// UntagResourceRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UntagResourceRequest(arg0 *cognitoidentityprovider.UntagResourceInput) (*request.Request, *cognitoidentityprovider.UntagResourceOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UntagResourceOutput)
+	return ret0, ret1
+}
+
+// UntagResourceRequest indicates an expected call of UntagResourceRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UntagResourceRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UntagResourceRequest), arg0)
+}
+
+// UntagResourceWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UntagResourceWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UntagResourceInput, arg2 ...request.Option) (*cognitoidentityprovider.UntagResourceOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UntagResourceOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UntagResourceWithContext indicates an expected call of UntagResourceWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UntagResourceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UntagResourceWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UntagResourceWithContext), varargs...)
+}
+
+// UpdateAuthEventFeedback mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateAuthEventFeedback(arg0 *cognitoidentityprovider.UpdateAuthEventFeedbackInput) (*cognitoidentityprovider.UpdateAuthEventFeedbackOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateAuthEventFeedback", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateAuthEventFeedbackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateAuthEventFeedback indicates an expected call of UpdateAuthEventFeedback.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateAuthEventFeedback(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthEventFeedback", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateAuthEventFeedback), arg0)
+}
+
+// UpdateAuthEventFeedbackRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateAuthEventFeedbackRequest(arg0 *cognitoidentityprovider.UpdateAuthEventFeedbackInput) (*request.Request, *cognitoidentityprovider.UpdateAuthEventFeedbackOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateAuthEventFeedbackRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateAuthEventFeedbackOutput)
+	return ret0, ret1
+}
+
+// UpdateAuthEventFeedbackRequest indicates an expected call of UpdateAuthEventFeedbackRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateAuthEventFeedbackRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthEventFeedbackRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateAuthEventFeedbackRequest), arg0)
+}
+
+// UpdateAuthEventFeedbackWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateAuthEventFeedbackWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateAuthEventFeedbackInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateAuthEventFeedbackOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateAuthEventFeedbackWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateAuthEventFeedbackOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateAuthEventFeedbackWithContext indicates an expected call of UpdateAuthEventFeedbackWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateAuthEventFeedbackWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAuthEventFeedbackWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateAuthEventFeedbackWithContext), varargs...)
+}
+
+// UpdateDeviceStatus mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateDeviceStatus(arg0 *cognitoidentityprovider.UpdateDeviceStatusInput) (*cognitoidentityprovider.UpdateDeviceStatusOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDeviceStatus", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateDeviceStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDeviceStatus indicates an expected call of UpdateDeviceStatus.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateDeviceStatus(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeviceStatus", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateDeviceStatus), arg0)
+}
+
+// UpdateDeviceStatusRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateDeviceStatusRequest(arg0 *cognitoidentityprovider.UpdateDeviceStatusInput) (*request.Request, *cognitoidentityprovider.UpdateDeviceStatusOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDeviceStatusRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateDeviceStatusOutput)
+	return ret0, ret1
+}
+
+// UpdateDeviceStatusRequest indicates an expected call of UpdateDeviceStatusRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateDeviceStatusRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeviceStatusRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateDeviceStatusRequest), arg0)
+}
+
+// UpdateDeviceStatusWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateDeviceStatusWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateDeviceStatusInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateDeviceStatusOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateDeviceStatusWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateDeviceStatusOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDeviceStatusWithContext indicates an expected call of UpdateDeviceStatusWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateDeviceStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeviceStatusWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateDeviceStatusWithContext), varargs...)
+}
+
+// UpdateGroup mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateGroup(arg0 *cognitoidentityprovider.UpdateGroupInput) (*cognitoidentityprovider.UpdateGroupOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateGroup", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateGroup indicates an expected call of UpdateGroup.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateGroup(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroup", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateGroup), arg0)
+}
+
+// UpdateGroupRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateGroupRequest(arg0 *cognitoidentityprovider.UpdateGroupInput) (*request.Request, *cognitoidentityprovider.UpdateGroupOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateGroupRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateGroupOutput)
+	return ret0, ret1
+}
+
+// UpdateGroupRequest indicates an expected call of UpdateGroupRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateGroupRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateGroupRequest), arg0)
+}
+
+// UpdateGroupWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateGroupWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateGroupInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateGroupOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateGroupWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateGroupOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateGroupWithContext indicates an expected call of UpdateGroupWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateGroupWithContext), varargs...)
+}
+
+// UpdateIdentityProvider mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateIdentityProvider(arg0 *cognitoidentityprovider.UpdateIdentityProviderInput) (*cognitoidentityprovider.UpdateIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateIdentityProvider", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateIdentityProvider indicates an expected call of UpdateIdentityProvider.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateIdentityProvider(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentityProvider", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateIdentityProvider), arg0)
+}
+
+// UpdateIdentityProviderRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateIdentityProviderRequest(arg0 *cognitoidentityprovider.UpdateIdentityProviderInput) (*request.Request, *cognitoidentityprovider.UpdateIdentityProviderOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateIdentityProviderRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateIdentityProviderOutput)
+	return ret0, ret1
+}
+
+// UpdateIdentityProviderRequest indicates an expected call of UpdateIdentityProviderRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateIdentityProviderRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentityProviderRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateIdentityProviderRequest), arg0)
+}
+
+// UpdateIdentityProviderWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateIdentityProviderWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateIdentityProviderInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateIdentityProviderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateIdentityProviderWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateIdentityProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateIdentityProviderWithContext indicates an expected call of UpdateIdentityProviderWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateIdentityProviderWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIdentityProviderWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateIdentityProviderWithContext), varargs...)
+}
+
+// UpdateResourceServer mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateResourceServer(arg0 *cognitoidentityprovider.UpdateResourceServerInput) (*cognitoidentityprovider.UpdateResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateResourceServer", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateResourceServer indicates an expected call of UpdateResourceServer.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateResourceServer(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourceServer", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateResourceServer), arg0)
+}
+
+// UpdateResourceServerRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateResourceServerRequest(arg0 *cognitoidentityprovider.UpdateResourceServerInput) (*request.Request, *cognitoidentityprovider.UpdateResourceServerOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateResourceServerRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateResourceServerOutput)
+	return ret0, ret1
+}
+
+// UpdateResourceServerRequest indicates an expected call of UpdateResourceServerRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateResourceServerRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourceServerRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateResourceServerRequest), arg0)
+}
+
+// UpdateResourceServerWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateResourceServerWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateResourceServerInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateResourceServerOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateResourceServerWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateResourceServerOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateResourceServerWithContext indicates an expected call of UpdateResourceServerWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateResourceServerWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateResourceServerWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateResourceServerWithContext), varargs...)
+}
+
+// UpdateUserAttributes mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserAttributes(arg0 *cognitoidentityprovider.UpdateUserAttributesInput) (*cognitoidentityprovider.UpdateUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserAttributes", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserAttributes indicates an expected call of UpdateUserAttributes.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserAttributes(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserAttributes", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserAttributes), arg0)
+}
+
+// UpdateUserAttributesRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserAttributesRequest(arg0 *cognitoidentityprovider.UpdateUserAttributesInput) (*request.Request, *cognitoidentityprovider.UpdateUserAttributesOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserAttributesRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateUserAttributesOutput)
+	return ret0, ret1
+}
+
+// UpdateUserAttributesRequest indicates an expected call of UpdateUserAttributesRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserAttributesRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserAttributesRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserAttributesRequest), arg0)
+}
+
+// UpdateUserAttributesWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserAttributesWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateUserAttributesInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateUserAttributesOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateUserAttributesWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserAttributesOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserAttributesWithContext indicates an expected call of UpdateUserAttributesWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserAttributesWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserAttributesWithContext), varargs...)
+}
+
+// UpdateUserPool mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPool(arg0 *cognitoidentityprovider.UpdateUserPoolInput) (*cognitoidentityprovider.UpdateUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserPool", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserPool indicates an expected call of UpdateUserPool.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPool(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPool", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPool), arg0)
+}
+
+// UpdateUserPoolClient mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolClient(arg0 *cognitoidentityprovider.UpdateUserPoolClientInput) (*cognitoidentityprovider.UpdateUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserPoolClient", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserPoolClient indicates an expected call of UpdateUserPoolClient.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolClient(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolClient", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolClient), arg0)
+}
+
+// UpdateUserPoolClientRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolClientRequest(arg0 *cognitoidentityprovider.UpdateUserPoolClientInput) (*request.Request, *cognitoidentityprovider.UpdateUserPoolClientOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserPoolClientRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateUserPoolClientOutput)
+	return ret0, ret1
+}
+
+// UpdateUserPoolClientRequest indicates an expected call of UpdateUserPoolClientRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolClientRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolClientRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolClientRequest), arg0)
+}
+
+// UpdateUserPoolClientWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolClientWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateUserPoolClientInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateUserPoolClientOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateUserPoolClientWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserPoolClientOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserPoolClientWithContext indicates an expected call of UpdateUserPoolClientWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolClientWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolClientWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolClientWithContext), varargs...)
+}
+
+// UpdateUserPoolDomain mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolDomain(arg0 *cognitoidentityprovider.UpdateUserPoolDomainInput) (*cognitoidentityprovider.UpdateUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserPoolDomain", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserPoolDomain indicates an expected call of UpdateUserPoolDomain.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolDomain(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolDomain", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolDomain), arg0)
+}
+
+// UpdateUserPoolDomainRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolDomainRequest(arg0 *cognitoidentityprovider.UpdateUserPoolDomainInput) (*request.Request, *cognitoidentityprovider.UpdateUserPoolDomainOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserPoolDomainRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateUserPoolDomainOutput)
+	return ret0, ret1
+}
+
+// UpdateUserPoolDomainRequest indicates an expected call of UpdateUserPoolDomainRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolDomainRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolDomainRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolDomainRequest), arg0)
+}
+
+// UpdateUserPoolDomainWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolDomainWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateUserPoolDomainInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateUserPoolDomainOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateUserPoolDomainWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserPoolDomainOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserPoolDomainWithContext indicates an expected call of UpdateUserPoolDomainWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolDomainWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolDomainWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolDomainWithContext), varargs...)
+}
+
+// UpdateUserPoolRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolRequest(arg0 *cognitoidentityprovider.UpdateUserPoolInput) (*request.Request, *cognitoidentityprovider.UpdateUserPoolOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateUserPoolRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.UpdateUserPoolOutput)
+	return ret0, ret1
+}
+
+// UpdateUserPoolRequest indicates an expected call of UpdateUserPoolRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolRequest), arg0)
+}
+
+// UpdateUserPoolWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) UpdateUserPoolWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.UpdateUserPoolInput, arg2 ...request.Option) (*cognitoidentityprovider.UpdateUserPoolOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "UpdateUserPoolWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.UpdateUserPoolOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateUserPoolWithContext indicates an expected call of UpdateUserPoolWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) UpdateUserPoolWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateUserPoolWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).UpdateUserPoolWithContext), varargs...)
+}
+
+// VerifySoftwareToken mocks base method.
+func (m *MockCognitoIdentityProviderAPI) VerifySoftwareToken(arg0 *cognitoidentityprovider.VerifySoftwareTokenInput) (*cognitoidentityprovider.VerifySoftwareTokenOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "VerifySoftwareToken", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.VerifySoftwareTokenOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// VerifySoftwareToken indicates an expected call of VerifySoftwareToken.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) VerifySoftwareToken(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifySoftwareToken", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).VerifySoftwareToken), arg0)
+}
+
+// VerifySoftwareTokenRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) VerifySoftwareTokenRequest(arg0 *cognitoidentityprovider.VerifySoftwareTokenInput) (*request.Request, *cognitoidentityprovider.VerifySoftwareTokenOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "VerifySoftwareTokenRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.VerifySoftwareTokenOutput)
+	return ret0, ret1
+}
+
+// VerifySoftwareTokenRequest indicates an expected call of VerifySoftwareTokenRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) VerifySoftwareTokenRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifySoftwareTokenRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).VerifySoftwareTokenRequest), arg0)
+}
+
+// VerifySoftwareTokenWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) VerifySoftwareTokenWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.VerifySoftwareTokenInput, arg2 ...request.Option) (*cognitoidentityprovider.VerifySoftwareTokenOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "VerifySoftwareTokenWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.VerifySoftwareTokenOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// VerifySoftwareTokenWithContext indicates an expected call of VerifySoftwareTokenWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) VerifySoftwareTokenWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifySoftwareTokenWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).VerifySoftwareTokenWithContext), varargs...)
+}
+
+// VerifyUserAttribute mocks base method.
+func (m *MockCognitoIdentityProviderAPI) VerifyUserAttribute(arg0 *cognitoidentityprovider.VerifyUserAttributeInput) (*cognitoidentityprovider.VerifyUserAttributeOutput, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "VerifyUserAttribute", arg0)
+	ret0, _ := ret[0].(*cognitoidentityprovider.VerifyUserAttributeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// VerifyUserAttribute indicates an expected call of VerifyUserAttribute.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) VerifyUserAttribute(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUserAttribute", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).VerifyUserAttribute), arg0)
+}
+
+// VerifyUserAttributeRequest mocks base method.
+func (m *MockCognitoIdentityProviderAPI) VerifyUserAttributeRequest(arg0 *cognitoidentityprovider.VerifyUserAttributeInput) (*request.Request, *cognitoidentityprovider.VerifyUserAttributeOutput) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "VerifyUserAttributeRequest", arg0)
+	ret0, _ := ret[0].(*request.Request)
+	ret1, _ := ret[1].(*cognitoidentityprovider.VerifyUserAttributeOutput)
+	return ret0, ret1
+}
+
+// VerifyUserAttributeRequest indicates an expected call of VerifyUserAttributeRequest.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) VerifyUserAttributeRequest(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUserAttributeRequest", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).VerifyUserAttributeRequest), arg0)
+}
+
+// VerifyUserAttributeWithContext mocks base method.
+func (m *MockCognitoIdentityProviderAPI) VerifyUserAttributeWithContext(arg0 aws.Context, arg1 *cognitoidentityprovider.VerifyUserAttributeInput, arg2 ...request.Option) (*cognitoidentityprovider.VerifyUserAttributeOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{arg0, arg1}
+	for _, a := range arg2 {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "VerifyUserAttributeWithContext", varargs...)
+	ret0, _ := ret[0].(*cognitoidentityprovider.VerifyUserAttributeOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// VerifyUserAttributeWithContext indicates an expected call of VerifyUserAttributeWithContext.
+func (mr *MockCognitoIdentityProviderAPIMockRecorder) VerifyUserAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{arg0, arg1}, arg2...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyUserAttributeWithContext", reflect.TypeOf((*MockCognitoIdentityProviderAPI)(nil).VerifyUserAttributeWithContext), varargs...)
+}
diff --git a/resources/cognito-identity-pools.go b/resources/cognito-identity-pool.go
similarity index 86%
rename from resources/cognito-identity-pools.go
rename to resources/cognito-identity-pool.go
index 7161c95d..259ff078 100644
--- a/resources/cognito-identity-pools.go
+++ b/resources/cognito-identity-pool.go
@@ -64,14 +64,14 @@ func (l *CognitoIdentityPoolLister) List(_ context.Context, o interface{}) ([]re
 	return resources, nil
 }
 
-func (f *CognitoIdentityPool) Remove(_ context.Context) error {
-	_, err := f.svc.DeleteIdentityPool(&cognitoidentity.DeleteIdentityPoolInput{
-		IdentityPoolId: f.id,
+func (r *CognitoIdentityPool) Remove(_ context.Context) error {
+	_, err := r.svc.DeleteIdentityPool(&cognitoidentity.DeleteIdentityPoolInput{
+		IdentityPoolId: r.id,
 	})
 
 	return err
 }
 
-func (f *CognitoIdentityPool) String() string {
-	return *f.name
+func (r *CognitoIdentityPool) String() string {
+	return *r.name
 }
diff --git a/resources/cognito-identity-providers.go b/resources/cognito-identity-provider.go
similarity index 81%
rename from resources/cognito-identity-providers.go
rename to resources/cognito-identity-provider.go
index fb3417eb..2ca22276 100644
--- a/resources/cognito-identity-providers.go
+++ b/resources/cognito-identity-provider.go
@@ -90,23 +90,23 @@ type CognitoIdentityProvider struct {
 	userPoolID   *string
 }
 
-func (p *CognitoIdentityProvider) Remove(_ context.Context) error {
-	_, err := p.svc.DeleteIdentityProvider(&cognitoidentityprovider.DeleteIdentityProviderInput{
-		UserPoolId:   p.userPoolID,
-		ProviderName: p.name,
+func (r *CognitoIdentityProvider) Remove(_ context.Context) error {
+	_, err := r.svc.DeleteIdentityProvider(&cognitoidentityprovider.DeleteIdentityProviderInput{
+		UserPoolId:   r.userPoolID,
+		ProviderName: r.name,
 	})
 
 	return err
 }
 
-func (p *CognitoIdentityProvider) Properties() types.Properties {
+func (r *CognitoIdentityProvider) Properties() types.Properties {
 	properties := types.NewProperties()
-	properties.Set("Type", p.providerType)
-	properties.Set("UserPoolName", p.userPoolName)
-	properties.Set("Name", p.name)
+	properties.Set("Type", r.providerType)
+	properties.Set("UserPoolName", r.userPoolName)
+	properties.Set("Name", r.name)
 	return properties
 }
 
-func (p *CognitoIdentityProvider) String() string {
-	return fmt.Sprintf("%s -> %s", ptr.ToString(p.userPoolName), ptr.ToString(p.name))
+func (r *CognitoIdentityProvider) String() string {
+	return fmt.Sprintf("%s -> %s", ptr.ToString(r.userPoolName), ptr.ToString(r.name))
 }
diff --git a/resources/cognito-userpool-clients.go b/resources/cognito-userpool-client.go
similarity index 82%
rename from resources/cognito-userpool-clients.go
rename to resources/cognito-userpool-client.go
index 90698b5e..5b891443 100644
--- a/resources/cognito-userpool-clients.go
+++ b/resources/cognito-userpool-client.go
@@ -88,23 +88,23 @@ type CognitoUserPoolClient struct {
 	userPoolID   *string
 }
 
-func (p *CognitoUserPoolClient) Remove(_ context.Context) error {
-	_, err := p.svc.DeleteUserPoolClient(&cognitoidentityprovider.DeleteUserPoolClientInput{
-		ClientId:   p.id,
-		UserPoolId: p.userPoolID,
+func (r *CognitoUserPoolClient) Remove(_ context.Context) error {
+	_, err := r.svc.DeleteUserPoolClient(&cognitoidentityprovider.DeleteUserPoolClientInput{
+		ClientId:   r.id,
+		UserPoolId: r.userPoolID,
 	})
 
 	return err
 }
 
-func (p *CognitoUserPoolClient) Properties() types.Properties {
+func (r *CognitoUserPoolClient) Properties() types.Properties {
 	properties := types.NewProperties()
-	properties.Set("ID", p.id)
-	properties.Set("Name", p.name)
-	properties.Set("UserPoolName", p.userPoolName)
+	properties.Set("ID", r.id)
+	properties.Set("Name", r.name)
+	properties.Set("UserPoolName", r.userPoolName)
 	return properties
 }
 
-func (p *CognitoUserPoolClient) String() string {
-	return fmt.Sprintf("%s -> %s", *p.userPoolName, *p.name)
+func (r *CognitoUserPoolClient) String() string {
+	return fmt.Sprintf("%s -> %s", *r.userPoolName, *r.name)
 }
diff --git a/resources/cognito-userpool-domains.go b/resources/cognito-userpool-domain.go
similarity index 87%
rename from resources/cognito-userpool-domains.go
rename to resources/cognito-userpool-domain.go
index 09eed86f..8de833b5 100644
--- a/resources/cognito-userpool-domains.go
+++ b/resources/cognito-userpool-domain.go
@@ -75,16 +75,16 @@ type CognitoUserPoolDomain struct {
 	userPoolID   *string
 }
 
-func (f *CognitoUserPoolDomain) Remove(_ context.Context) error {
+func (r *CognitoUserPoolDomain) Remove(_ context.Context) error {
 	params := &cognitoidentityprovider.DeleteUserPoolDomainInput{
-		Domain:     f.name,
-		UserPoolId: f.userPoolID,
+		Domain:     r.name,
+		UserPoolId: r.userPoolID,
 	}
-	_, err := f.svc.DeleteUserPoolDomain(params)
+	_, err := r.svc.DeleteUserPoolDomain(params)
 
 	return err
 }
 
-func (f *CognitoUserPoolDomain) String() string {
-	return fmt.Sprintf("%s -> %s", *f.userPoolName, *f.name)
+func (r *CognitoUserPoolDomain) String() string {
+	return fmt.Sprintf("%s -> %s", *r.userPoolName, *r.name)
 }
diff --git a/resources/cognito-userpools.go b/resources/cognito-userpool.go
similarity index 62%
rename from resources/cognito-userpools.go
rename to resources/cognito-userpool.go
index b6a7f526..ea332670 100644
--- a/resources/cognito-userpools.go
+++ b/resources/cognito-userpool.go
@@ -9,11 +9,13 @@ import (
 
 	"github.com/aws/aws-sdk-go/aws"
 	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
+	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider/cognitoidentityprovideriface"
 	"github.com/aws/aws-sdk-go/service/sts"
 	"github.com/aws/aws-sdk-go/service/sts/stsiface"
 
 	"github.com/ekristen/libnuke/pkg/registry"
 	"github.com/ekristen/libnuke/pkg/resource"
+	"github.com/ekristen/libnuke/pkg/settings"
 	"github.com/ekristen/libnuke/pkg/types"
 
 	"github.com/ekristen/aws-nuke/v3/pkg/nuke"
@@ -26,6 +28,9 @@ func init() {
 		Name:   CognitoUserPoolResource,
 		Scope:  nuke.Account,
 		Lister: &CognitoUserPoolLister{},
+		Settings: []string{
+			"DisableDeletionProtection",
+		},
 		DependsOn: []string{
 			CognitoIdentityPoolResource,
 			CognitoUserPoolClientResource,
@@ -35,11 +40,13 @@ func init() {
 }
 
 type CognitoUserPoolLister struct {
-	stsService stsiface.STSAPI
+	stsService     stsiface.STSAPI
+	cognitoService cognitoidentityprovideriface.CognitoIdentityProviderAPI
 }
 
 func (l *CognitoUserPoolLister) List(_ context.Context, o interface{}) ([]resource.Resource, error) {
 	opts := o.(*nuke.ListerOpts)
+	resources := make([]resource.Resource, 0)
 
 	var stsSvc stsiface.STSAPI
 	if l.stsService != nil {
@@ -48,8 +55,12 @@ func (l *CognitoUserPoolLister) List(_ context.Context, o interface{}) ([]resour
 		stsSvc = sts.New(opts.Session)
 	}
 
-	svc := cognitoidentityprovider.New(opts.Session)
-	resources := make([]resource.Resource, 0)
+	var svc cognitoidentityprovideriface.CognitoIdentityProviderAPI
+	if l.cognitoService != nil {
+		svc = l.cognitoService
+	} else {
+		svc = cognitoidentityprovider.New(opts.Session)
+	}
 
 	identityOutput, err := stsSvc.GetCallerIdentity(nil)
 	if err != nil {
@@ -95,24 +106,39 @@ func (l *CognitoUserPoolLister) List(_ context.Context, o interface{}) ([]resour
 }
 
 type CognitoUserPool struct {
-	svc  *cognitoidentityprovider.CognitoIdentityProvider
-	Name *string
-	ID   *string
-	Tags map[string]*string
+	svc      cognitoidentityprovideriface.CognitoIdentityProviderAPI
+	settings *settings.Setting
+	Name     *string
+	ID       *string
+	Tags     map[string]*string
 }
 
-func (f *CognitoUserPool) Remove(_ context.Context) error {
-	_, err := f.svc.DeleteUserPool(&cognitoidentityprovider.DeleteUserPoolInput{
-		UserPoolId: f.ID,
+func (r *CognitoUserPool) Remove(_ context.Context) error {
+	if r.settings.GetBool("DisableDeletionProtection") {
+		_, err := r.svc.UpdateUserPool(&cognitoidentityprovider.UpdateUserPoolInput{
+			UserPoolId:         r.ID,
+			DeletionProtection: ptr.String("INACTIVE"),
+		})
+		if err != nil {
+			return err
+		}
+	}
+
+	_, err := r.svc.DeleteUserPool(&cognitoidentityprovider.DeleteUserPoolInput{
+		UserPoolId: r.ID,
 	})
 
 	return err
 }
 
-func (f *CognitoUserPool) Properties() types.Properties {
-	return types.NewPropertiesFromStruct(f)
+func (r *CognitoUserPool) Properties() types.Properties {
+	return types.NewPropertiesFromStruct(r)
+}
+
+func (r *CognitoUserPool) String() string {
+	return *r.Name
 }
 
-func (f *CognitoUserPool) String() string {
-	return *f.Name
+func (r *CognitoUserPool) Settings(setting *settings.Setting) {
+	r.settings = setting
 }
diff --git a/resources/cognito-userpool_mock_test.go b/resources/cognito-userpool_mock_test.go
new file mode 100644
index 00000000..ba63a3fd
--- /dev/null
+++ b/resources/cognito-userpool_mock_test.go
@@ -0,0 +1,149 @@
+package resources
+
+import (
+	"context"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/sts"
+
+	"github.com/aws/aws-sdk-go/service/cognitoidentityprovider"
+
+	"github.com/ekristen/libnuke/pkg/settings"
+
+	"github.com/ekristen/aws-nuke/v3/mocks/mock_cognitoidentityprovideriface"
+	"github.com/ekristen/aws-nuke/v3/mocks/mock_stsiface"
+	"github.com/ekristen/aws-nuke/v3/pkg/nuke"
+)
+
+func Test_Mock_CognitoUserPool_List(t *testing.T) {
+	a := assert.New(t)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockSvc := mock_cognitoidentityprovideriface.NewMockCognitoIdentityProviderAPI(ctrl)
+	mockStsSvc := mock_stsiface.NewMockSTSAPI(ctrl)
+
+	lister := &CognitoUserPoolLister{
+		stsService:     mockStsSvc,
+		cognitoService: mockSvc,
+	}
+
+	mockStsSvc.EXPECT().GetCallerIdentity(gomock.Any()).Return(&sts.GetCallerIdentityOutput{
+		Account: aws.String("123456789012"),
+	}, nil)
+
+	mockSvc.EXPECT().ListUserPools(&cognitoidentityprovider.ListUserPoolsInput{
+		MaxResults: aws.Int64(50),
+	}).Return(&cognitoidentityprovider.ListUserPoolsOutput{
+		UserPools: []*cognitoidentityprovider.UserPoolDescriptionType{
+			{
+				Id:   aws.String("test-pool-id"),
+				Name: aws.String("test-pool"),
+			},
+		},
+	}, nil)
+
+	mockSvc.EXPECT().ListTagsForResource(&cognitoidentityprovider.ListTagsForResourceInput{
+		ResourceArn: aws.String("arn:aws:cognito-idp:us-east-2:123456789012:userpool/test-pool-id"),
+	}).Return(&cognitoidentityprovider.ListTagsForResourceOutput{
+		Tags: map[string]*string{
+			"test-key": aws.String("test-value"),
+		},
+	}, nil)
+
+	resources, err := lister.List(context.TODO(), &nuke.ListerOpts{
+		Region: &nuke.Region{
+			Name: "us-east-2",
+		},
+		Session: session.Must(session.NewSession()),
+	})
+	a.NoError(err)
+	a.Len(resources, 1)
+}
+
+func Test_Mock_CognitoUserPool_Remove(t *testing.T) {
+	a := assert.New(t)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockSvc := mock_cognitoidentityprovideriface.NewMockCognitoIdentityProviderAPI(ctrl)
+
+	mockSvc.EXPECT().DeleteUserPool(&cognitoidentityprovider.DeleteUserPoolInput{
+		UserPoolId: aws.String("test-pool-id"),
+	}).Return(&cognitoidentityprovider.DeleteUserPoolOutput{}, nil)
+
+	s := &settings.Setting{}
+	s.Set("DisableDeletionProtection", false)
+
+	pool := &CognitoUserPool{
+		svc:      mockSvc,
+		settings: s,
+		Name:     aws.String("test-pool"),
+		ID:       aws.String("test-pool-id"),
+		Tags: map[string]*string{
+			"test-key": aws.String("test-value"),
+		},
+	}
+
+	err := pool.Remove(context.TODO())
+	a.NoError(err)
+}
+
+func Test_Mock_CognitoUserPool_Remove_DeletionProtection(t *testing.T) {
+	a := assert.New(t)
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	mockSvc := mock_cognitoidentityprovideriface.NewMockCognitoIdentityProviderAPI(ctrl)
+
+	mockSvc.EXPECT().UpdateUserPool(&cognitoidentityprovider.UpdateUserPoolInput{
+		UserPoolId:         aws.String("test-pool-id"),
+		DeletionProtection: aws.String("INACTIVE"),
+	}).Return(&cognitoidentityprovider.UpdateUserPoolOutput{}, nil)
+
+	mockSvc.EXPECT().DeleteUserPool(&cognitoidentityprovider.DeleteUserPoolInput{
+		UserPoolId: aws.String("test-pool-id"),
+	}).Return(&cognitoidentityprovider.DeleteUserPoolOutput{}, nil)
+
+	s := &settings.Setting{}
+	s.Set("DisableDeletionProtection", true)
+
+	pool := &CognitoUserPool{
+		svc:      mockSvc,
+		settings: s,
+		Name:     aws.String("test-pool"),
+		ID:       aws.String("test-pool-id"),
+		Tags: map[string]*string{
+			"test-key": aws.String("test-value"),
+		},
+	}
+
+	err := pool.Remove(context.TODO())
+	a.NoError(err)
+}
+
+func Test_Mock_CognitoUserPool_Properties(t *testing.T) {
+	a := assert.New(t)
+
+	s := &settings.Setting{}
+	s.Set("DisableDeletionProtection", false)
+
+	pool := &CognitoUserPool{
+		settings: s,
+		Name:     aws.String("test-pool"),
+		ID:       aws.String("test-pool-id"),
+		Tags: map[string]*string{
+			"test-key": aws.String("test-value"),
+		},
+	}
+
+	a.Equal("test-pool", pool.Properties().Get("Name"))
+	a.Equal("test-pool-id", pool.Properties().Get("ID"))
+	a.Equal("test-value", pool.Properties().Get("tag:test-key"))
+	a.Equal("test-pool", pool.String())
+}
diff --git a/resources/cognito_mock_test.go b/resources/cognito_mock_test.go
new file mode 100644
index 00000000..2d8148fd
--- /dev/null
+++ b/resources/cognito_mock_test.go
@@ -0,0 +1,2 @@
+//go:generate ../mocks/generate_mocks.sh cognitoidentityprovider cognitoidentityprovideriface
+package resources