// Code generated by MockGen. DO NOT EDIT.
// Source: service.go

// Package service is a generated GoMock package.
package service

import (
	context "context"
	reflect "reflect"

	model "github.com/authgear/authgear-server/pkg/api/model"
	identity "github.com/authgear/authgear-server/pkg/lib/authn/identity"
	loginid "github.com/authgear/authgear-server/pkg/lib/authn/identity/loginid"
	oauthrelyingparty "github.com/authgear/oauthrelyingparty/pkg/api/oauthrelyingparty"
	gomock "github.com/golang/mock/gomock"
)

// MockLoginIDIdentityProvider is a mock of LoginIDIdentityProvider interface.
type MockLoginIDIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockLoginIDIdentityProviderMockRecorder
}

// MockLoginIDIdentityProviderMockRecorder is the mock recorder for MockLoginIDIdentityProvider.
type MockLoginIDIdentityProviderMockRecorder struct {
	mock *MockLoginIDIdentityProvider
}

// NewMockLoginIDIdentityProvider creates a new mock instance.
func NewMockLoginIDIdentityProvider(ctrl *gomock.Controller) *MockLoginIDIdentityProvider {
	mock := &MockLoginIDIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockLoginIDIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLoginIDIdentityProvider) EXPECT() *MockLoginIDIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockLoginIDIdentityProvider) Create(ctx context.Context, i *identity.LoginID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockLoginIDIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockLoginIDIdentityProvider) Delete(ctx context.Context, i *identity.LoginID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockLoginIDIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockLoginIDIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLoginIDIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetByKeyAndValue mocks base method.
func (m *MockLoginIDIdentityProvider) GetByKeyAndValue(ctx context.Context, loginIDKey, loginIDValue string) (*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByKeyAndValue", ctx, loginIDKey, loginIDValue)
	ret0, _ := ret[0].(*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByKeyAndValue indicates an expected call of GetByKeyAndValue.
func (mr *MockLoginIDIdentityProviderMockRecorder) GetByKeyAndValue(ctx, loginIDKey, loginIDValue interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByKeyAndValue", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).GetByKeyAndValue), ctx, loginIDKey, loginIDValue)
}

// GetByUniqueKey mocks base method.
func (m *MockLoginIDIdentityProvider) GetByUniqueKey(ctx context.Context, uniqueKey string) (*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByUniqueKey", ctx, uniqueKey)
	ret0, _ := ret[0].(*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByUniqueKey indicates an expected call of GetByUniqueKey.
func (mr *MockLoginIDIdentityProviderMockRecorder) GetByUniqueKey(ctx, uniqueKey interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByUniqueKey", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).GetByUniqueKey), ctx, uniqueKey)
}

// GetByValue mocks base method.
func (m *MockLoginIDIdentityProvider) GetByValue(ctx context.Context, loginIDValue string) ([]*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByValue", ctx, loginIDValue)
	ret0, _ := ret[0].([]*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByValue indicates an expected call of GetByValue.
func (mr *MockLoginIDIdentityProviderMockRecorder) GetByValue(ctx, loginIDValue interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByValue", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).GetByValue), ctx, loginIDValue)
}

// GetMany mocks base method.
func (m *MockLoginIDIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockLoginIDIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockLoginIDIdentityProvider) List(ctx context.Context, userID string) ([]*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockLoginIDIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).List), ctx, userID)
}

// ListByClaim mocks base method.
func (m *MockLoginIDIdentityProvider) ListByClaim(ctx context.Context, name, value string) ([]*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByClaim", ctx, name, value)
	ret0, _ := ret[0].([]*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListByClaim indicates an expected call of ListByClaim.
func (mr *MockLoginIDIdentityProviderMockRecorder) ListByClaim(ctx, name, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByClaim", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).ListByClaim), ctx, name, value)
}

// New mocks base method.
func (m *MockLoginIDIdentityProvider) New(ctx context.Context, userID string, loginID identity.LoginIDSpec, options loginid.CheckerOptions) (*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", ctx, userID, loginID, options)
	ret0, _ := ret[0].(*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// New indicates an expected call of New.
func (mr *MockLoginIDIdentityProviderMockRecorder) New(ctx, userID, loginID, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).New), ctx, userID, loginID, options)
}

// Normalize mocks base method.
func (m *MockLoginIDIdentityProvider) Normalize(typ model.LoginIDKeyType, value string) (string, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Normalize", typ, value)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Normalize indicates an expected call of Normalize.
func (mr *MockLoginIDIdentityProviderMockRecorder) Normalize(typ, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Normalize", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).Normalize), typ, value)
}

// Update mocks base method.
func (m *MockLoginIDIdentityProvider) Update(ctx context.Context, i *identity.LoginID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockLoginIDIdentityProviderMockRecorder) Update(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).Update), ctx, i)
}

// WithValue mocks base method.
func (m *MockLoginIDIdentityProvider) WithValue(ctx context.Context, iden *identity.LoginID, value string, options loginid.CheckerOptions) (*identity.LoginID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithValue", ctx, iden, value, options)
	ret0, _ := ret[0].(*identity.LoginID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WithValue indicates an expected call of WithValue.
func (mr *MockLoginIDIdentityProviderMockRecorder) WithValue(ctx, iden, value, options interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithValue", reflect.TypeOf((*MockLoginIDIdentityProvider)(nil).WithValue), ctx, iden, value, options)
}

// MockOAuthIdentityProvider is a mock of OAuthIdentityProvider interface.
type MockOAuthIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockOAuthIdentityProviderMockRecorder
}

// MockOAuthIdentityProviderMockRecorder is the mock recorder for MockOAuthIdentityProvider.
type MockOAuthIdentityProviderMockRecorder struct {
	mock *MockOAuthIdentityProvider
}

// NewMockOAuthIdentityProvider creates a new mock instance.
func NewMockOAuthIdentityProvider(ctrl *gomock.Controller) *MockOAuthIdentityProvider {
	mock := &MockOAuthIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockOAuthIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockOAuthIdentityProvider) EXPECT() *MockOAuthIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockOAuthIdentityProvider) Create(ctx context.Context, i *identity.OAuth) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockOAuthIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockOAuthIdentityProvider) Delete(ctx context.Context, i *identity.OAuth) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockOAuthIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockOAuthIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.OAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.OAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockOAuthIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetByProviderSubject mocks base method.
func (m *MockOAuthIdentityProvider) GetByProviderSubject(ctx context.Context, providerID oauthrelyingparty.ProviderID, subjectID string) (*identity.OAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByProviderSubject", ctx, providerID, subjectID)
	ret0, _ := ret[0].(*identity.OAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByProviderSubject indicates an expected call of GetByProviderSubject.
func (mr *MockOAuthIdentityProviderMockRecorder) GetByProviderSubject(ctx, providerID, subjectID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByProviderSubject", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).GetByProviderSubject), ctx, providerID, subjectID)
}

// GetByUserProvider mocks base method.
func (m *MockOAuthIdentityProvider) GetByUserProvider(ctx context.Context, userID string, providerID oauthrelyingparty.ProviderID) (*identity.OAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByUserProvider", ctx, userID, providerID)
	ret0, _ := ret[0].(*identity.OAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByUserProvider indicates an expected call of GetByUserProvider.
func (mr *MockOAuthIdentityProviderMockRecorder) GetByUserProvider(ctx, userID, providerID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByUserProvider", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).GetByUserProvider), ctx, userID, providerID)
}

// GetMany mocks base method.
func (m *MockOAuthIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.OAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.OAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockOAuthIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockOAuthIdentityProvider) List(ctx context.Context, userID string) ([]*identity.OAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.OAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockOAuthIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).List), ctx, userID)
}

// ListByClaim mocks base method.
func (m *MockOAuthIdentityProvider) ListByClaim(ctx context.Context, name, value string) ([]*identity.OAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByClaim", ctx, name, value)
	ret0, _ := ret[0].([]*identity.OAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListByClaim indicates an expected call of ListByClaim.
func (mr *MockOAuthIdentityProviderMockRecorder) ListByClaim(ctx, name, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByClaim", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).ListByClaim), ctx, name, value)
}

// New mocks base method.
func (m *MockOAuthIdentityProvider) New(userID string, spec *identity.OAuthSpec) *identity.OAuth {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", userID, spec)
	ret0, _ := ret[0].(*identity.OAuth)
	return ret0
}

// New indicates an expected call of New.
func (mr *MockOAuthIdentityProviderMockRecorder) New(userID, spec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).New), userID, spec)
}

// Update mocks base method.
func (m *MockOAuthIdentityProvider) Update(ctx context.Context, i *identity.OAuth) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockOAuthIdentityProviderMockRecorder) Update(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).Update), ctx, i)
}

// WithUpdate mocks base method.
func (m *MockOAuthIdentityProvider) WithUpdate(iden *identity.OAuth, spec *identity.OAuthSpec) *identity.OAuth {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithUpdate", iden, spec)
	ret0, _ := ret[0].(*identity.OAuth)
	return ret0
}

// WithUpdate indicates an expected call of WithUpdate.
func (mr *MockOAuthIdentityProviderMockRecorder) WithUpdate(iden, spec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithUpdate", reflect.TypeOf((*MockOAuthIdentityProvider)(nil).WithUpdate), iden, spec)
}

// MockAnonymousIdentityProvider is a mock of AnonymousIdentityProvider interface.
type MockAnonymousIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockAnonymousIdentityProviderMockRecorder
}

// MockAnonymousIdentityProviderMockRecorder is the mock recorder for MockAnonymousIdentityProvider.
type MockAnonymousIdentityProviderMockRecorder struct {
	mock *MockAnonymousIdentityProvider
}

// NewMockAnonymousIdentityProvider creates a new mock instance.
func NewMockAnonymousIdentityProvider(ctrl *gomock.Controller) *MockAnonymousIdentityProvider {
	mock := &MockAnonymousIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockAnonymousIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockAnonymousIdentityProvider) EXPECT() *MockAnonymousIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockAnonymousIdentityProvider) Create(ctx context.Context, i *identity.Anonymous) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockAnonymousIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockAnonymousIdentityProvider) Delete(ctx context.Context, i *identity.Anonymous) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockAnonymousIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockAnonymousIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.Anonymous, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.Anonymous)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockAnonymousIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetByKeyID mocks base method.
func (m *MockAnonymousIdentityProvider) GetByKeyID(ctx context.Context, keyID string) (*identity.Anonymous, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByKeyID", ctx, keyID)
	ret0, _ := ret[0].(*identity.Anonymous)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByKeyID indicates an expected call of GetByKeyID.
func (mr *MockAnonymousIdentityProviderMockRecorder) GetByKeyID(ctx, keyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByKeyID", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).GetByKeyID), ctx, keyID)
}

// GetMany mocks base method.
func (m *MockAnonymousIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.Anonymous, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.Anonymous)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockAnonymousIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockAnonymousIdentityProvider) List(ctx context.Context, userID string) ([]*identity.Anonymous, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.Anonymous)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockAnonymousIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).List), ctx, userID)
}

// New mocks base method.
func (m *MockAnonymousIdentityProvider) New(userID, keyID string, key []byte) *identity.Anonymous {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", userID, keyID, key)
	ret0, _ := ret[0].(*identity.Anonymous)
	return ret0
}

// New indicates an expected call of New.
func (mr *MockAnonymousIdentityProviderMockRecorder) New(userID, keyID, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockAnonymousIdentityProvider)(nil).New), userID, keyID, key)
}

// MockBiometricIdentityProvider is a mock of BiometricIdentityProvider interface.
type MockBiometricIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockBiometricIdentityProviderMockRecorder
}

// MockBiometricIdentityProviderMockRecorder is the mock recorder for MockBiometricIdentityProvider.
type MockBiometricIdentityProviderMockRecorder struct {
	mock *MockBiometricIdentityProvider
}

// NewMockBiometricIdentityProvider creates a new mock instance.
func NewMockBiometricIdentityProvider(ctrl *gomock.Controller) *MockBiometricIdentityProvider {
	mock := &MockBiometricIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockBiometricIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBiometricIdentityProvider) EXPECT() *MockBiometricIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockBiometricIdentityProvider) Create(ctx context.Context, i *identity.Biometric) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockBiometricIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockBiometricIdentityProvider) Delete(ctx context.Context, i *identity.Biometric) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockBiometricIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockBiometricIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.Biometric, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.Biometric)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockBiometricIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetByKeyID mocks base method.
func (m *MockBiometricIdentityProvider) GetByKeyID(ctx context.Context, keyID string) (*identity.Biometric, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByKeyID", ctx, keyID)
	ret0, _ := ret[0].(*identity.Biometric)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByKeyID indicates an expected call of GetByKeyID.
func (mr *MockBiometricIdentityProviderMockRecorder) GetByKeyID(ctx, keyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByKeyID", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).GetByKeyID), ctx, keyID)
}

// GetMany mocks base method.
func (m *MockBiometricIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.Biometric, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.Biometric)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockBiometricIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockBiometricIdentityProvider) List(ctx context.Context, userID string) ([]*identity.Biometric, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.Biometric)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockBiometricIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).List), ctx, userID)
}

// New mocks base method.
func (m *MockBiometricIdentityProvider) New(userID, keyID string, key []byte, deviceInfo map[string]interface{}) *identity.Biometric {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", userID, keyID, key, deviceInfo)
	ret0, _ := ret[0].(*identity.Biometric)
	return ret0
}

// New indicates an expected call of New.
func (mr *MockBiometricIdentityProviderMockRecorder) New(userID, keyID, key, deviceInfo interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockBiometricIdentityProvider)(nil).New), userID, keyID, key, deviceInfo)
}

// MockPasskeyIdentityProvider is a mock of PasskeyIdentityProvider interface.
type MockPasskeyIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockPasskeyIdentityProviderMockRecorder
}

// MockPasskeyIdentityProviderMockRecorder is the mock recorder for MockPasskeyIdentityProvider.
type MockPasskeyIdentityProviderMockRecorder struct {
	mock *MockPasskeyIdentityProvider
}

// NewMockPasskeyIdentityProvider creates a new mock instance.
func NewMockPasskeyIdentityProvider(ctrl *gomock.Controller) *MockPasskeyIdentityProvider {
	mock := &MockPasskeyIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockPasskeyIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPasskeyIdentityProvider) EXPECT() *MockPasskeyIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockPasskeyIdentityProvider) Create(ctx context.Context, i *identity.Passkey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockPasskeyIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockPasskeyIdentityProvider) Delete(ctx context.Context, i *identity.Passkey) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockPasskeyIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockPasskeyIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.Passkey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.Passkey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockPasskeyIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetBySpec mocks base method.
func (m *MockPasskeyIdentityProvider) GetBySpec(ctx context.Context, spec *identity.PasskeySpec) (*identity.Passkey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBySpec", ctx, spec)
	ret0, _ := ret[0].(*identity.Passkey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBySpec indicates an expected call of GetBySpec.
func (mr *MockPasskeyIdentityProviderMockRecorder) GetBySpec(ctx, spec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBySpec", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).GetBySpec), ctx, spec)
}

// GetMany mocks base method.
func (m *MockPasskeyIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.Passkey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.Passkey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockPasskeyIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockPasskeyIdentityProvider) List(ctx context.Context, userID string) ([]*identity.Passkey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.Passkey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockPasskeyIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).List), ctx, userID)
}

// New mocks base method.
func (m *MockPasskeyIdentityProvider) New(ctx context.Context, userID string, attestationResponse []byte) (*identity.Passkey, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", ctx, userID, attestationResponse)
	ret0, _ := ret[0].(*identity.Passkey)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// New indicates an expected call of New.
func (mr *MockPasskeyIdentityProviderMockRecorder) New(ctx, userID, attestationResponse interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockPasskeyIdentityProvider)(nil).New), ctx, userID, attestationResponse)
}

// MockSIWEIdentityProvider is a mock of SIWEIdentityProvider interface.
type MockSIWEIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockSIWEIdentityProviderMockRecorder
}

// MockSIWEIdentityProviderMockRecorder is the mock recorder for MockSIWEIdentityProvider.
type MockSIWEIdentityProviderMockRecorder struct {
	mock *MockSIWEIdentityProvider
}

// NewMockSIWEIdentityProvider creates a new mock instance.
func NewMockSIWEIdentityProvider(ctrl *gomock.Controller) *MockSIWEIdentityProvider {
	mock := &MockSIWEIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockSIWEIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockSIWEIdentityProvider) EXPECT() *MockSIWEIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockSIWEIdentityProvider) Create(ctx context.Context, i *identity.SIWE) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockSIWEIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockSIWEIdentityProvider) Delete(ctx context.Context, i *identity.SIWE) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockSIWEIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockSIWEIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.SIWE, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.SIWE)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockSIWEIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetByMessage mocks base method.
func (m *MockSIWEIdentityProvider) GetByMessage(ctx context.Context, msg, signature string) (*identity.SIWE, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByMessage", ctx, msg, signature)
	ret0, _ := ret[0].(*identity.SIWE)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByMessage indicates an expected call of GetByMessage.
func (mr *MockSIWEIdentityProviderMockRecorder) GetByMessage(ctx, msg, signature interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByMessage", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).GetByMessage), ctx, msg, signature)
}

// GetMany mocks base method.
func (m *MockSIWEIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.SIWE, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.SIWE)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockSIWEIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockSIWEIdentityProvider) List(ctx context.Context, userID string) ([]*identity.SIWE, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.SIWE)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockSIWEIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).List), ctx, userID)
}

// New mocks base method.
func (m *MockSIWEIdentityProvider) New(ctx context.Context, userID, msg, signature string) (*identity.SIWE, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", ctx, userID, msg, signature)
	ret0, _ := ret[0].(*identity.SIWE)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// New indicates an expected call of New.
func (mr *MockSIWEIdentityProviderMockRecorder) New(ctx, userID, msg, signature interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockSIWEIdentityProvider)(nil).New), ctx, userID, msg, signature)
}

// MockLDAPIdentityProvider is a mock of LDAPIdentityProvider interface.
type MockLDAPIdentityProvider struct {
	ctrl     *gomock.Controller
	recorder *MockLDAPIdentityProviderMockRecorder
}

// MockLDAPIdentityProviderMockRecorder is the mock recorder for MockLDAPIdentityProvider.
type MockLDAPIdentityProviderMockRecorder struct {
	mock *MockLDAPIdentityProvider
}

// NewMockLDAPIdentityProvider creates a new mock instance.
func NewMockLDAPIdentityProvider(ctrl *gomock.Controller) *MockLDAPIdentityProvider {
	mock := &MockLDAPIdentityProvider{ctrl: ctrl}
	mock.recorder = &MockLDAPIdentityProviderMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLDAPIdentityProvider) EXPECT() *MockLDAPIdentityProviderMockRecorder {
	return m.recorder
}

// Create mocks base method.
func (m *MockLDAPIdentityProvider) Create(ctx context.Context, i *identity.LDAP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Create indicates an expected call of Create.
func (mr *MockLDAPIdentityProviderMockRecorder) Create(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).Create), ctx, i)
}

// Delete mocks base method.
func (m *MockLDAPIdentityProvider) Delete(ctx context.Context, i *identity.LDAP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockLDAPIdentityProviderMockRecorder) Delete(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).Delete), ctx, i)
}

// Get mocks base method.
func (m *MockLDAPIdentityProvider) Get(ctx context.Context, userID, id string) (*identity.LDAP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, userID, id)
	ret0, _ := ret[0].(*identity.LDAP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLDAPIdentityProviderMockRecorder) Get(ctx, userID, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).Get), ctx, userID, id)
}

// GetByServerUserID mocks base method.
func (m *MockLDAPIdentityProvider) GetByServerUserID(ctx context.Context, serverName, userIDAttributeName string, userIDAttributeValue []byte) (*identity.LDAP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetByServerUserID", ctx, serverName, userIDAttributeName, userIDAttributeValue)
	ret0, _ := ret[0].(*identity.LDAP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByServerUserID indicates an expected call of GetByServerUserID.
func (mr *MockLDAPIdentityProviderMockRecorder) GetByServerUserID(ctx, serverName, userIDAttributeName, userIDAttributeValue interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByServerUserID", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).GetByServerUserID), ctx, serverName, userIDAttributeName, userIDAttributeValue)
}

// GetMany mocks base method.
func (m *MockLDAPIdentityProvider) GetMany(ctx context.Context, ids []string) ([]*identity.LDAP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMany", ctx, ids)
	ret0, _ := ret[0].([]*identity.LDAP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMany indicates an expected call of GetMany.
func (mr *MockLDAPIdentityProviderMockRecorder) GetMany(ctx, ids interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMany", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).GetMany), ctx, ids)
}

// List mocks base method.
func (m *MockLDAPIdentityProvider) List(ctx context.Context, userID string) ([]*identity.LDAP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", ctx, userID)
	ret0, _ := ret[0].([]*identity.LDAP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockLDAPIdentityProviderMockRecorder) List(ctx, userID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).List), ctx, userID)
}

// ListByClaim mocks base method.
func (m *MockLDAPIdentityProvider) ListByClaim(ctx context.Context, name, value string) ([]*identity.LDAP, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListByClaim", ctx, name, value)
	ret0, _ := ret[0].([]*identity.LDAP)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListByClaim indicates an expected call of ListByClaim.
func (mr *MockLDAPIdentityProviderMockRecorder) ListByClaim(ctx, name, value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListByClaim", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).ListByClaim), ctx, name, value)
}

// New mocks base method.
func (m *MockLDAPIdentityProvider) New(userID, serverName string, loginUserName *string, userIDAttributeName string, userIDAttributeValue []byte, claims, rawEntryJSON map[string]interface{}) *identity.LDAP {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", userID, serverName, loginUserName, userIDAttributeName, userIDAttributeValue, claims, rawEntryJSON)
	ret0, _ := ret[0].(*identity.LDAP)
	return ret0
}

// New indicates an expected call of New.
func (mr *MockLDAPIdentityProviderMockRecorder) New(userID, serverName, loginUserName, userIDAttributeName, userIDAttributeValue, claims, rawEntryJSON interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).New), userID, serverName, loginUserName, userIDAttributeName, userIDAttributeValue, claims, rawEntryJSON)
}

// Update mocks base method.
func (m *MockLDAPIdentityProvider) Update(ctx context.Context, i *identity.LDAP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, i)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockLDAPIdentityProviderMockRecorder) Update(ctx, i interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).Update), ctx, i)
}

// WithUpdate mocks base method.
func (m *MockLDAPIdentityProvider) WithUpdate(iden *identity.LDAP, loginUserName *string, claims, rawEntryJSON map[string]interface{}) *identity.LDAP {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithUpdate", iden, loginUserName, claims, rawEntryJSON)
	ret0, _ := ret[0].(*identity.LDAP)
	return ret0
}

// WithUpdate indicates an expected call of WithUpdate.
func (mr *MockLDAPIdentityProviderMockRecorder) WithUpdate(iden, loginUserName, claims, rawEntryJSON interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithUpdate", reflect.TypeOf((*MockLDAPIdentityProvider)(nil).WithUpdate), iden, loginUserName, claims, rawEntryJSON)
}
