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

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

import (
	context "context"
	reflect "reflect"

	authenticationinfo "github.com/authgear/authgear-server/pkg/lib/authn/authenticationinfo"
	config "github.com/authgear/authgear-server/pkg/lib/config"
	oauthsession "github.com/authgear/authgear-server/pkg/lib/oauth/oauthsession"
	gomock "github.com/golang/mock/gomock"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// CreateFlow mocks base method.
func (m *MockStore) CreateFlow(ctx context.Context, flow *Flow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFlow", ctx, flow)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateFlow indicates an expected call of CreateFlow.
func (mr *MockStoreMockRecorder) CreateFlow(ctx, flow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlow", reflect.TypeOf((*MockStore)(nil).CreateFlow), ctx, flow)
}

// CreateSession mocks base method.
func (m *MockStore) CreateSession(ctx context.Context, session *Session) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSession", ctx, session)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateSession indicates an expected call of CreateSession.
func (mr *MockStoreMockRecorder) CreateSession(ctx, session interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSession", reflect.TypeOf((*MockStore)(nil).CreateSession), ctx, session)
}

// DeleteFlow mocks base method.
func (m *MockStore) DeleteFlow(ctx context.Context, flow *Flow) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFlow", ctx, flow)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFlow indicates an expected call of DeleteFlow.
func (mr *MockStoreMockRecorder) DeleteFlow(ctx, flow interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlow", reflect.TypeOf((*MockStore)(nil).DeleteFlow), ctx, flow)
}

// DeleteSession mocks base method.
func (m *MockStore) DeleteSession(ctx context.Context, session *Session) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSession", ctx, session)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSession indicates an expected call of DeleteSession.
func (mr *MockStoreMockRecorder) DeleteSession(ctx, session interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSession", reflect.TypeOf((*MockStore)(nil).DeleteSession), ctx, session)
}

// GetFlowByStateToken mocks base method.
func (m *MockStore) GetFlowByStateToken(ctx context.Context, stateToken string) (*Flow, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFlowByStateToken", ctx, stateToken)
	ret0, _ := ret[0].(*Flow)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFlowByStateToken indicates an expected call of GetFlowByStateToken.
func (mr *MockStoreMockRecorder) GetFlowByStateToken(ctx, stateToken interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFlowByStateToken", reflect.TypeOf((*MockStore)(nil).GetFlowByStateToken), ctx, stateToken)
}

// GetSession mocks base method.
func (m *MockStore) GetSession(ctx context.Context, flowID string) (*Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSession", ctx, flowID)
	ret0, _ := ret[0].(*Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSession indicates an expected call of GetSession.
func (mr *MockStoreMockRecorder) GetSession(ctx, flowID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSession", reflect.TypeOf((*MockStore)(nil).GetSession), ctx, flowID)
}

// UpdateSession mocks base method.
func (m *MockStore) UpdateSession(ctx context.Context, session *Session) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSession", ctx, session)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateSession indicates an expected call of UpdateSession.
func (mr *MockStoreMockRecorder) UpdateSession(ctx, session interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSession", reflect.TypeOf((*MockStore)(nil).UpdateSession), ctx, session)
}

// MockServiceDatabase is a mock of ServiceDatabase interface.
type MockServiceDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockServiceDatabaseMockRecorder
}

// MockServiceDatabaseMockRecorder is the mock recorder for MockServiceDatabase.
type MockServiceDatabaseMockRecorder struct {
	mock *MockServiceDatabase
}

// NewMockServiceDatabase creates a new mock instance.
func NewMockServiceDatabase(ctrl *gomock.Controller) *MockServiceDatabase {
	mock := &MockServiceDatabase{ctrl: ctrl}
	mock.recorder = &MockServiceDatabaseMockRecorder{mock}
	return mock
}

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

// ReadOnly mocks base method.
func (m *MockServiceDatabase) ReadOnly(ctx context.Context, do func(context.Context) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReadOnly", ctx, do)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReadOnly indicates an expected call of ReadOnly.
func (mr *MockServiceDatabaseMockRecorder) ReadOnly(ctx, do interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadOnly", reflect.TypeOf((*MockServiceDatabase)(nil).ReadOnly), ctx, do)
}

// WithTx mocks base method.
func (m *MockServiceDatabase) WithTx(ctx context.Context, do func(context.Context) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WithTx", ctx, do)
	ret0, _ := ret[0].(error)
	return ret0
}

// WithTx indicates an expected call of WithTx.
func (mr *MockServiceDatabaseMockRecorder) WithTx(ctx, do interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTx", reflect.TypeOf((*MockServiceDatabase)(nil).WithTx), ctx, do)
}

// MockServiceUIInfoResolver is a mock of ServiceUIInfoResolver interface.
type MockServiceUIInfoResolver struct {
	ctrl     *gomock.Controller
	recorder *MockServiceUIInfoResolverMockRecorder
}

// MockServiceUIInfoResolverMockRecorder is the mock recorder for MockServiceUIInfoResolver.
type MockServiceUIInfoResolverMockRecorder struct {
	mock *MockServiceUIInfoResolver
}

// NewMockServiceUIInfoResolver creates a new mock instance.
func NewMockServiceUIInfoResolver(ctrl *gomock.Controller) *MockServiceUIInfoResolver {
	mock := &MockServiceUIInfoResolver{ctrl: ctrl}
	mock.recorder = &MockServiceUIInfoResolverMockRecorder{mock}
	return mock
}

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

// SetAuthenticationInfoInQuery mocks base method.
func (m *MockServiceUIInfoResolver) SetAuthenticationInfoInQuery(redirectURI string, e *authenticationinfo.Entry) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAuthenticationInfoInQuery", redirectURI, e)
	ret0, _ := ret[0].(string)
	return ret0
}

// SetAuthenticationInfoInQuery indicates an expected call of SetAuthenticationInfoInQuery.
func (mr *MockServiceUIInfoResolverMockRecorder) SetAuthenticationInfoInQuery(redirectURI, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAuthenticationInfoInQuery", reflect.TypeOf((*MockServiceUIInfoResolver)(nil).SetAuthenticationInfoInQuery), redirectURI, e)
}

// MockOAuthClientResolver is a mock of OAuthClientResolver interface.
type MockOAuthClientResolver struct {
	ctrl     *gomock.Controller
	recorder *MockOAuthClientResolverMockRecorder
}

// MockOAuthClientResolverMockRecorder is the mock recorder for MockOAuthClientResolver.
type MockOAuthClientResolverMockRecorder struct {
	mock *MockOAuthClientResolver
}

// NewMockOAuthClientResolver creates a new mock instance.
func NewMockOAuthClientResolver(ctrl *gomock.Controller) *MockOAuthClientResolver {
	mock := &MockOAuthClientResolver{ctrl: ctrl}
	mock.recorder = &MockOAuthClientResolverMockRecorder{mock}
	return mock
}

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

// ResolveClient mocks base method.
func (m *MockOAuthClientResolver) ResolveClient(clientID string) *config.OAuthClientConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResolveClient", clientID)
	ret0, _ := ret[0].(*config.OAuthClientConfig)
	return ret0
}

// ResolveClient indicates an expected call of ResolveClient.
func (mr *MockOAuthClientResolverMockRecorder) ResolveClient(clientID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveClient", reflect.TypeOf((*MockOAuthClientResolver)(nil).ResolveClient), clientID)
}

// MockOAuthSessionStore is a mock of OAuthSessionStore interface.
type MockOAuthSessionStore struct {
	ctrl     *gomock.Controller
	recorder *MockOAuthSessionStoreMockRecorder
}

// MockOAuthSessionStoreMockRecorder is the mock recorder for MockOAuthSessionStore.
type MockOAuthSessionStoreMockRecorder struct {
	mock *MockOAuthSessionStore
}

// NewMockOAuthSessionStore creates a new mock instance.
func NewMockOAuthSessionStore(ctrl *gomock.Controller) *MockOAuthSessionStore {
	mock := &MockOAuthSessionStore{ctrl: ctrl}
	mock.recorder = &MockOAuthSessionStoreMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockOAuthSessionStore) Get(ctx context.Context, entryID string) (*oauthsession.Entry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", ctx, entryID)
	ret0, _ := ret[0].(*oauthsession.Entry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Save mocks base method.
func (m *MockOAuthSessionStore) Save(ctx context.Context, entry *oauthsession.Entry) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Save", ctx, entry)
	ret0, _ := ret[0].(error)
	return ret0
}

// Save indicates an expected call of Save.
func (mr *MockOAuthSessionStoreMockRecorder) Save(ctx, entry interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Save", reflect.TypeOf((*MockOAuthSessionStore)(nil).Save), ctx, entry)
}
