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

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

import (
	context "context"
	reflect "reflect"

	event "github.com/authgear/authgear-server/pkg/api/event"
	db "github.com/authgear/authgear-server/pkg/lib/infra/db"
	gomock "github.com/golang/mock/gomock"
)

// MockDatabase is a mock of Database interface.
type MockDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseMockRecorder
}

// MockDatabaseMockRecorder is the mock recorder for MockDatabase.
type MockDatabaseMockRecorder struct {
	mock *MockDatabase
}

// NewMockDatabase creates a new mock instance.
func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase {
	mock := &MockDatabase{ctrl: ctrl}
	mock.recorder = &MockDatabaseMockRecorder{mock}
	return mock
}

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

// UseHook mocks base method.
func (m *MockDatabase) UseHook(ctx context.Context, hook db.TransactionHook) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UseHook", ctx, hook)
}

// UseHook indicates an expected call of UseHook.
func (mr *MockDatabaseMockRecorder) UseHook(ctx, hook interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UseHook", reflect.TypeOf((*MockDatabase)(nil).UseHook), ctx, hook)
}

// MockSink is a mock of Sink interface.
type MockSink struct {
	ctrl     *gomock.Controller
	recorder *MockSinkMockRecorder
}

// MockSinkMockRecorder is the mock recorder for MockSink.
type MockSinkMockRecorder struct {
	mock *MockSink
}

// NewMockSink creates a new mock instance.
func NewMockSink(ctrl *gomock.Controller) *MockSink {
	mock := &MockSink{ctrl: ctrl}
	mock.recorder = &MockSinkMockRecorder{mock}
	return mock
}

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

// ReceiveBlockingEvent mocks base method.
func (m *MockSink) ReceiveBlockingEvent(ctx context.Context, e *event.Event) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveBlockingEvent", ctx, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReceiveBlockingEvent indicates an expected call of ReceiveBlockingEvent.
func (mr *MockSinkMockRecorder) ReceiveBlockingEvent(ctx, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveBlockingEvent", reflect.TypeOf((*MockSink)(nil).ReceiveBlockingEvent), ctx, e)
}

// ReceiveNonBlockingEvent mocks base method.
func (m *MockSink) ReceiveNonBlockingEvent(ctx context.Context, e *event.Event) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReceiveNonBlockingEvent", ctx, e)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReceiveNonBlockingEvent indicates an expected call of ReceiveNonBlockingEvent.
func (mr *MockSinkMockRecorder) ReceiveNonBlockingEvent(ctx, e interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReceiveNonBlockingEvent", reflect.TypeOf((*MockSink)(nil).ReceiveNonBlockingEvent), ctx, e)
}

// 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
}

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

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

// MockResolver is a mock of Resolver interface.
type MockResolver struct {
	ctrl     *gomock.Controller
	recorder *MockResolverMockRecorder
}

// MockResolverMockRecorder is the mock recorder for MockResolver.
type MockResolverMockRecorder struct {
	mock *MockResolver
}

// NewMockResolver creates a new mock instance.
func NewMockResolver(ctrl *gomock.Controller) *MockResolver {
	mock := &MockResolver{ctrl: ctrl}
	mock.recorder = &MockResolverMockRecorder{mock}
	return mock
}

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

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

// Resolve indicates an expected call of Resolve.
func (mr *MockResolverMockRecorder) Resolve(ctx, anything interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Resolve", reflect.TypeOf((*MockResolver)(nil).Resolve), ctx, anything)
}
