// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/ProtonMail/proton-bridge/v3/internal/services/userevents (interfaces: EventSubscriber,MessageEventHandler,LabelEventHandler,AddressEventHandler,RefreshEventHandler,UserEventHandler,UserUsedSpaceEventHandler)

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

import (
	context "context"
	reflect "reflect"

	proton "github.com/ProtonMail/go-proton-api"
	gomock "github.com/golang/mock/gomock"
)

// MockEventSubscriber is a mock of EventSubscriber interface.
type MockEventSubscriber struct {
	ctrl     *gomock.Controller
	recorder *MockEventSubscriberMockRecorder
}

// MockEventSubscriberMockRecorder is the mock recorder for MockEventSubscriber.
type MockEventSubscriberMockRecorder struct {
	mock *MockEventSubscriber
}

// NewMockEventSubscriber creates a new mock instance.
func NewMockEventSubscriber(ctrl *gomock.Controller) *MockEventSubscriber {
	mock := &MockEventSubscriber{ctrl: ctrl}
	mock.recorder = &MockEventSubscriberMockRecorder{mock}
	return mock
}

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

// cancel mocks base method.
func (m *MockEventSubscriber) cancel() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "cancel")
}

// cancel indicates an expected call of cancel.
func (mr *MockEventSubscriberMockRecorder) cancel() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "cancel", reflect.TypeOf((*MockEventSubscriber)(nil).cancel))
}

// close mocks base method.
func (m *MockEventSubscriber) close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "close")
}

// close indicates an expected call of close.
func (mr *MockEventSubscriberMockRecorder) close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "close", reflect.TypeOf((*MockEventSubscriber)(nil).close))
}

// handle mocks base method.
func (m *MockEventSubscriber) handle(arg0 context.Context, arg1 proton.Event) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "handle", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// handle indicates an expected call of handle.
func (mr *MockEventSubscriberMockRecorder) handle(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handle", reflect.TypeOf((*MockEventSubscriber)(nil).handle), arg0, arg1)
}

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

// name indicates an expected call of name.
func (mr *MockEventSubscriberMockRecorder) name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "name", reflect.TypeOf((*MockEventSubscriber)(nil).name))
}

// MockMessageEventHandler is a mock of MessageEventHandler interface.
type MockMessageEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockMessageEventHandlerMockRecorder
}

// MockMessageEventHandlerMockRecorder is the mock recorder for MockMessageEventHandler.
type MockMessageEventHandlerMockRecorder struct {
	mock *MockMessageEventHandler
}

// NewMockMessageEventHandler creates a new mock instance.
func NewMockMessageEventHandler(ctrl *gomock.Controller) *MockMessageEventHandler {
	mock := &MockMessageEventHandler{ctrl: ctrl}
	mock.recorder = &MockMessageEventHandlerMockRecorder{mock}
	return mock
}

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

// HandleMessageEvents mocks base method.
func (m *MockMessageEventHandler) HandleMessageEvents(arg0 context.Context, arg1 []proton.MessageEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleMessageEvents", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleMessageEvents indicates an expected call of HandleMessageEvents.
func (mr *MockMessageEventHandlerMockRecorder) HandleMessageEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessageEvents", reflect.TypeOf((*MockMessageEventHandler)(nil).HandleMessageEvents), arg0, arg1)
}

// MockLabelEventHandler is a mock of LabelEventHandler interface.
type MockLabelEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockLabelEventHandlerMockRecorder
}

// MockLabelEventHandlerMockRecorder is the mock recorder for MockLabelEventHandler.
type MockLabelEventHandlerMockRecorder struct {
	mock *MockLabelEventHandler
}

// NewMockLabelEventHandler creates a new mock instance.
func NewMockLabelEventHandler(ctrl *gomock.Controller) *MockLabelEventHandler {
	mock := &MockLabelEventHandler{ctrl: ctrl}
	mock.recorder = &MockLabelEventHandlerMockRecorder{mock}
	return mock
}

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

// HandleLabelEvents mocks base method.
func (m *MockLabelEventHandler) HandleLabelEvents(arg0 context.Context, arg1 []proton.LabelEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleLabelEvents", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleLabelEvents indicates an expected call of HandleLabelEvents.
func (mr *MockLabelEventHandlerMockRecorder) HandleLabelEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleLabelEvents", reflect.TypeOf((*MockLabelEventHandler)(nil).HandleLabelEvents), arg0, arg1)
}

// MockAddressEventHandler is a mock of AddressEventHandler interface.
type MockAddressEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockAddressEventHandlerMockRecorder
}

// MockAddressEventHandlerMockRecorder is the mock recorder for MockAddressEventHandler.
type MockAddressEventHandlerMockRecorder struct {
	mock *MockAddressEventHandler
}

// NewMockAddressEventHandler creates a new mock instance.
func NewMockAddressEventHandler(ctrl *gomock.Controller) *MockAddressEventHandler {
	mock := &MockAddressEventHandler{ctrl: ctrl}
	mock.recorder = &MockAddressEventHandlerMockRecorder{mock}
	return mock
}

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

// HandleAddressEvents mocks base method.
func (m *MockAddressEventHandler) HandleAddressEvents(arg0 context.Context, arg1 []proton.AddressEvent) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleAddressEvents", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleAddressEvents indicates an expected call of HandleAddressEvents.
func (mr *MockAddressEventHandlerMockRecorder) HandleAddressEvents(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleAddressEvents", reflect.TypeOf((*MockAddressEventHandler)(nil).HandleAddressEvents), arg0, arg1)
}

// MockRefreshEventHandler is a mock of RefreshEventHandler interface.
type MockRefreshEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockRefreshEventHandlerMockRecorder
}

// MockRefreshEventHandlerMockRecorder is the mock recorder for MockRefreshEventHandler.
type MockRefreshEventHandlerMockRecorder struct {
	mock *MockRefreshEventHandler
}

// NewMockRefreshEventHandler creates a new mock instance.
func NewMockRefreshEventHandler(ctrl *gomock.Controller) *MockRefreshEventHandler {
	mock := &MockRefreshEventHandler{ctrl: ctrl}
	mock.recorder = &MockRefreshEventHandlerMockRecorder{mock}
	return mock
}

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

// HandleRefreshEvent mocks base method.
func (m *MockRefreshEventHandler) HandleRefreshEvent(arg0 context.Context, arg1 proton.RefreshFlag) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleRefreshEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleRefreshEvent indicates an expected call of HandleRefreshEvent.
func (mr *MockRefreshEventHandlerMockRecorder) HandleRefreshEvent(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleRefreshEvent", reflect.TypeOf((*MockRefreshEventHandler)(nil).HandleRefreshEvent), arg0, arg1)
}

// MockUserEventHandler is a mock of UserEventHandler interface.
type MockUserEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockUserEventHandlerMockRecorder
}

// MockUserEventHandlerMockRecorder is the mock recorder for MockUserEventHandler.
type MockUserEventHandlerMockRecorder struct {
	mock *MockUserEventHandler
}

// NewMockUserEventHandler creates a new mock instance.
func NewMockUserEventHandler(ctrl *gomock.Controller) *MockUserEventHandler {
	mock := &MockUserEventHandler{ctrl: ctrl}
	mock.recorder = &MockUserEventHandlerMockRecorder{mock}
	return mock
}

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

// HandleUserEvent mocks base method.
func (m *MockUserEventHandler) HandleUserEvent(arg0 context.Context, arg1 *proton.User) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleUserEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleUserEvent indicates an expected call of HandleUserEvent.
func (mr *MockUserEventHandlerMockRecorder) HandleUserEvent(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleUserEvent", reflect.TypeOf((*MockUserEventHandler)(nil).HandleUserEvent), arg0, arg1)
}

// MockUserUsedSpaceEventHandler is a mock of UserUsedSpaceEventHandler interface.
type MockUserUsedSpaceEventHandler struct {
	ctrl     *gomock.Controller
	recorder *MockUserUsedSpaceEventHandlerMockRecorder
}

// MockUserUsedSpaceEventHandlerMockRecorder is the mock recorder for MockUserUsedSpaceEventHandler.
type MockUserUsedSpaceEventHandlerMockRecorder struct {
	mock *MockUserUsedSpaceEventHandler
}

// NewMockUserUsedSpaceEventHandler creates a new mock instance.
func NewMockUserUsedSpaceEventHandler(ctrl *gomock.Controller) *MockUserUsedSpaceEventHandler {
	mock := &MockUserUsedSpaceEventHandler{ctrl: ctrl}
	mock.recorder = &MockUserUsedSpaceEventHandlerMockRecorder{mock}
	return mock
}

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

// HandleUsedSpaceEvent mocks base method.
func (m *MockUserUsedSpaceEventHandler) HandleUsedSpaceEvent(arg0 context.Context, arg1 int64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleUsedSpaceEvent", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleUsedSpaceEvent indicates an expected call of HandleUsedSpaceEvent.
func (mr *MockUserUsedSpaceEventHandlerMockRecorder) HandleUsedSpaceEvent(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleUsedSpaceEvent", reflect.TypeOf((*MockUserUsedSpaceEventHandler)(nil).HandleUsedSpaceEvent), arg0, arg1)
}
