mk6i-open-oscar-server/server/icq_legacy/mock_legacy_service_test.go

// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package icq_legacy

import (
	"context"

	"github.com/mk6i/open-oscar-server/state"
	mock "github.com/stretchr/testify/mock"
)

// newMockLegacyService creates a new instance of mockLegacyService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func newMockLegacyService(t interface {
	mock.TestingT
	Cleanup(func())
}) *mockLegacyService {
	mock := &mockLegacyService{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}

// mockLegacyService is an autogenerated mock type for the LegacyService type
type mockLegacyService struct {
	mock.Mock
}

type mockLegacyService_Expecter struct {
	mock *mock.Mock
}

func (_m *mockLegacyService) EXPECT() *mockLegacyService_Expecter {
	return &mockLegacyService_Expecter{mock: &_m.Mock}
}

// AckOfflineMessages provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) AckOfflineMessages(ctx context.Context, uin uint32) error {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for AckOfflineMessages")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) error); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_AckOfflineMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AckOfflineMessages'
type mockLegacyService_AckOfflineMessages_Call struct {
	*mock.Call
}

// AckOfflineMessages is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) AckOfflineMessages(ctx interface{}, uin interface{}) *mockLegacyService_AckOfflineMessages_Call {
	return &mockLegacyService_AckOfflineMessages_Call{Call: _e.mock.On("AckOfflineMessages", ctx, uin)}
}

func (_c *mockLegacyService_AckOfflineMessages_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_AckOfflineMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_AckOfflineMessages_Call) Return(err error) *mockLegacyService_AckOfflineMessages_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_AckOfflineMessages_Call) RunAndReturn(run func(ctx context.Context, uin uint32) error) *mockLegacyService_AckOfflineMessages_Call {
	_c.Call.Return(run)
	return _c
}

// AuthenticateUser provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) AuthenticateUser(ctx context.Context, req AuthRequest) (*AuthResult, error) {
	ret := _mock.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for AuthenticateUser")
	}

	var r0 *AuthResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, AuthRequest) (*AuthResult, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, AuthRequest) *AuthResult); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*AuthResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, AuthRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_AuthenticateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AuthenticateUser'
type mockLegacyService_AuthenticateUser_Call struct {
	*mock.Call
}

// AuthenticateUser is a helper method to define mock.On call
//   - ctx context.Context
//   - req AuthRequest
func (_e *mockLegacyService_Expecter) AuthenticateUser(ctx interface{}, req interface{}) *mockLegacyService_AuthenticateUser_Call {
	return &mockLegacyService_AuthenticateUser_Call{Call: _e.mock.On("AuthenticateUser", ctx, req)}
}

func (_c *mockLegacyService_AuthenticateUser_Call) Run(run func(ctx context.Context, req AuthRequest)) *mockLegacyService_AuthenticateUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 AuthRequest
		if args[1] != nil {
			arg1 = args[1].(AuthRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_AuthenticateUser_Call) Return(authResult *AuthResult, err error) *mockLegacyService_AuthenticateUser_Call {
	_c.Call.Return(authResult, err)
	return _c
}

func (_c *mockLegacyService_AuthenticateUser_Call) RunAndReturn(run func(ctx context.Context, req AuthRequest) (*AuthResult, error)) *mockLegacyService_AuthenticateUser_Call {
	_c.Call.Return(run)
	return _c
}

// ChangeStatus provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) ChangeStatus(ctx context.Context, uin uint32, status uint32) error {
	ret := _mock.Called(ctx, uin, status)

	if len(ret) == 0 {
		panic("no return value specified for ChangeStatus")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, uint32) error); ok {
		r0 = returnFunc(ctx, uin, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_ChangeStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeStatus'
type mockLegacyService_ChangeStatus_Call struct {
	*mock.Call
}

// ChangeStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - status uint32
func (_e *mockLegacyService_Expecter) ChangeStatus(ctx interface{}, uin interface{}, status interface{}) *mockLegacyService_ChangeStatus_Call {
	return &mockLegacyService_ChangeStatus_Call{Call: _e.mock.On("ChangeStatus", ctx, uin, status)}
}

func (_c *mockLegacyService_ChangeStatus_Call) Run(run func(ctx context.Context, uin uint32, status uint32)) *mockLegacyService_ChangeStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 uint32
		if args[2] != nil {
			arg2 = args[2].(uint32)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_ChangeStatus_Call) Return(err error) *mockLegacyService_ChangeStatus_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_ChangeStatus_Call) RunAndReturn(run func(ctx context.Context, uin uint32, status uint32) error) *mockLegacyService_ChangeStatus_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteUser provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) DeleteUser(ctx context.Context, uin uint32, password string) error {
	ret := _mock.Called(ctx, uin, password)

	if len(ret) == 0 {
		panic("no return value specified for DeleteUser")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, string) error); ok {
		r0 = returnFunc(ctx, uin, password)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'
type mockLegacyService_DeleteUser_Call struct {
	*mock.Call
}

// DeleteUser is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - password string
func (_e *mockLegacyService_Expecter) DeleteUser(ctx interface{}, uin interface{}, password interface{}) *mockLegacyService_DeleteUser_Call {
	return &mockLegacyService_DeleteUser_Call{Call: _e.mock.On("DeleteUser", ctx, uin, password)}
}

func (_c *mockLegacyService_DeleteUser_Call) Run(run func(ctx context.Context, uin uint32, password string)) *mockLegacyService_DeleteUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_DeleteUser_Call) Return(err error) *mockLegacyService_DeleteUser_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_DeleteUser_Call) RunAndReturn(run func(ctx context.Context, uin uint32, password string) error) *mockLegacyService_DeleteUser_Call {
	_c.Call.Return(run)
	return _c
}

// GetAffiliations provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetAffiliations(ctx context.Context, uin uint32) (*state.ICQAffiliations, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetAffiliations")
	}

	var r0 *state.ICQAffiliations
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*state.ICQAffiliations, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *state.ICQAffiliations); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ICQAffiliations)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetAffiliations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAffiliations'
type mockLegacyService_GetAffiliations_Call struct {
	*mock.Call
}

// GetAffiliations is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetAffiliations(ctx interface{}, uin interface{}) *mockLegacyService_GetAffiliations_Call {
	return &mockLegacyService_GetAffiliations_Call{Call: _e.mock.On("GetAffiliations", ctx, uin)}
}

func (_c *mockLegacyService_GetAffiliations_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetAffiliations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetAffiliations_Call) Return(iCQAffiliations *state.ICQAffiliations, err error) *mockLegacyService_GetAffiliations_Call {
	_c.Call.Return(iCQAffiliations, err)
	return _c
}

func (_c *mockLegacyService_GetAffiliations_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (*state.ICQAffiliations, error)) *mockLegacyService_GetAffiliations_Call {
	_c.Call.Return(run)
	return _c
}

// GetFullUserInfo provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetFullUserInfo(ctx context.Context, uin uint32) (*state.User, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetFullUserInfo")
	}

	var r0 *state.User
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*state.User, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *state.User); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.User)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetFullUserInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetFullUserInfo'
type mockLegacyService_GetFullUserInfo_Call struct {
	*mock.Call
}

// GetFullUserInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetFullUserInfo(ctx interface{}, uin interface{}) *mockLegacyService_GetFullUserInfo_Call {
	return &mockLegacyService_GetFullUserInfo_Call{Call: _e.mock.On("GetFullUserInfo", ctx, uin)}
}

func (_c *mockLegacyService_GetFullUserInfo_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetFullUserInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetFullUserInfo_Call) Return(user *state.User, err error) *mockLegacyService_GetFullUserInfo_Call {
	_c.Call.Return(user, err)
	return _c
}

func (_c *mockLegacyService_GetFullUserInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (*state.User, error)) *mockLegacyService_GetFullUserInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetHomepageCategory provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetHomepageCategory(ctx context.Context, uin uint32) (*state.ICQHomepageCategory, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetHomepageCategory")
	}

	var r0 *state.ICQHomepageCategory
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*state.ICQHomepageCategory, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *state.ICQHomepageCategory); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ICQHomepageCategory)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetHomepageCategory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomepageCategory'
type mockLegacyService_GetHomepageCategory_Call struct {
	*mock.Call
}

// GetHomepageCategory is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetHomepageCategory(ctx interface{}, uin interface{}) *mockLegacyService_GetHomepageCategory_Call {
	return &mockLegacyService_GetHomepageCategory_Call{Call: _e.mock.On("GetHomepageCategory", ctx, uin)}
}

func (_c *mockLegacyService_GetHomepageCategory_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetHomepageCategory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetHomepageCategory_Call) Return(iCQHomepageCategory *state.ICQHomepageCategory, err error) *mockLegacyService_GetHomepageCategory_Call {
	_c.Call.Return(iCQHomepageCategory, err)
	return _c
}

func (_c *mockLegacyService_GetHomepageCategory_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (*state.ICQHomepageCategory, error)) *mockLegacyService_GetHomepageCategory_Call {
	_c.Call.Return(run)
	return _c
}

// GetInterests provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetInterests(ctx context.Context, uin uint32) (*state.ICQInterests, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetInterests")
	}

	var r0 *state.ICQInterests
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*state.ICQInterests, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *state.ICQInterests); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*state.ICQInterests)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetInterests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetInterests'
type mockLegacyService_GetInterests_Call struct {
	*mock.Call
}

// GetInterests is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetInterests(ctx interface{}, uin interface{}) *mockLegacyService_GetInterests_Call {
	return &mockLegacyService_GetInterests_Call{Call: _e.mock.On("GetInterests", ctx, uin)}
}

func (_c *mockLegacyService_GetInterests_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetInterests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetInterests_Call) Return(iCQInterests *state.ICQInterests, err error) *mockLegacyService_GetInterests_Call {
	_c.Call.Return(iCQInterests, err)
	return _c
}

func (_c *mockLegacyService_GetInterests_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (*state.ICQInterests, error)) *mockLegacyService_GetInterests_Call {
	_c.Call.Return(run)
	return _c
}

// GetNotes provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetNotes(ctx context.Context, uin uint32) (string, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetNotes")
	}

	var r0 string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (string, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) string); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		r0 = ret.Get(0).(string)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetNotes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetNotes'
type mockLegacyService_GetNotes_Call struct {
	*mock.Call
}

// GetNotes is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetNotes(ctx interface{}, uin interface{}) *mockLegacyService_GetNotes_Call {
	return &mockLegacyService_GetNotes_Call{Call: _e.mock.On("GetNotes", ctx, uin)}
}

func (_c *mockLegacyService_GetNotes_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetNotes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetNotes_Call) Return(s string, err error) *mockLegacyService_GetNotes_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *mockLegacyService_GetNotes_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (string, error)) *mockLegacyService_GetNotes_Call {
	_c.Call.Return(run)
	return _c
}

// GetOfflineMessages provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetOfflineMessages(ctx context.Context, uin uint32) ([]LegacyOfflineMessage, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetOfflineMessages")
	}

	var r0 []LegacyOfflineMessage
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) ([]LegacyOfflineMessage, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) []LegacyOfflineMessage); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]LegacyOfflineMessage)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetOfflineMessages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOfflineMessages'
type mockLegacyService_GetOfflineMessages_Call struct {
	*mock.Call
}

// GetOfflineMessages is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetOfflineMessages(ctx interface{}, uin interface{}) *mockLegacyService_GetOfflineMessages_Call {
	return &mockLegacyService_GetOfflineMessages_Call{Call: _e.mock.On("GetOfflineMessages", ctx, uin)}
}

func (_c *mockLegacyService_GetOfflineMessages_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetOfflineMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetOfflineMessages_Call) Return(legacyOfflineMessages []LegacyOfflineMessage, err error) *mockLegacyService_GetOfflineMessages_Call {
	_c.Call.Return(legacyOfflineMessages, err)
	return _c
}

func (_c *mockLegacyService_GetOfflineMessages_Call) RunAndReturn(run func(ctx context.Context, uin uint32) ([]LegacyOfflineMessage, error)) *mockLegacyService_GetOfflineMessages_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserInfo provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetUserInfo(ctx context.Context, uin uint32) (*LegacyUserSearchResult, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for GetUserInfo")
	}

	var r0 *LegacyUserSearchResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*LegacyUserSearchResult, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *LegacyUserSearchResult); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*LegacyUserSearchResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetUserInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserInfo'
type mockLegacyService_GetUserInfo_Call struct {
	*mock.Call
}

// GetUserInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) GetUserInfo(ctx interface{}, uin interface{}) *mockLegacyService_GetUserInfo_Call {
	return &mockLegacyService_GetUserInfo_Call{Call: _e.mock.On("GetUserInfo", ctx, uin)}
}

func (_c *mockLegacyService_GetUserInfo_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_GetUserInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetUserInfo_Call) Return(legacyUserSearchResult *LegacyUserSearchResult, err error) *mockLegacyService_GetUserInfo_Call {
	_c.Call.Return(legacyUserSearchResult, err)
	return _c
}

func (_c *mockLegacyService_GetUserInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (*LegacyUserSearchResult, error)) *mockLegacyService_GetUserInfo_Call {
	_c.Call.Return(run)
	return _c
}

// GetUserInfoForProtocol provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) GetUserInfoForProtocol(ctx context.Context, targetUIN uint32) (*UserInfoResult, error) {
	ret := _mock.Called(ctx, targetUIN)

	if len(ret) == 0 {
		panic("no return value specified for GetUserInfoForProtocol")
	}

	var r0 *UserInfoResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*UserInfoResult, error)); ok {
		return returnFunc(ctx, targetUIN)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *UserInfoResult); ok {
		r0 = returnFunc(ctx, targetUIN)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*UserInfoResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, targetUIN)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_GetUserInfoForProtocol_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserInfoForProtocol'
type mockLegacyService_GetUserInfoForProtocol_Call struct {
	*mock.Call
}

// GetUserInfoForProtocol is a helper method to define mock.On call
//   - ctx context.Context
//   - targetUIN uint32
func (_e *mockLegacyService_Expecter) GetUserInfoForProtocol(ctx interface{}, targetUIN interface{}) *mockLegacyService_GetUserInfoForProtocol_Call {
	return &mockLegacyService_GetUserInfoForProtocol_Call{Call: _e.mock.On("GetUserInfoForProtocol", ctx, targetUIN)}
}

func (_c *mockLegacyService_GetUserInfoForProtocol_Call) Run(run func(ctx context.Context, targetUIN uint32)) *mockLegacyService_GetUserInfoForProtocol_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_GetUserInfoForProtocol_Call) Return(userInfoResult *UserInfoResult, err error) *mockLegacyService_GetUserInfoForProtocol_Call {
	_c.Call.Return(userInfoResult, err)
	return _c
}

func (_c *mockLegacyService_GetUserInfoForProtocol_Call) RunAndReturn(run func(ctx context.Context, targetUIN uint32) (*UserInfoResult, error)) *mockLegacyService_GetUserInfoForProtocol_Call {
	_c.Call.Return(run)
	return _c
}

// NotifyStatusChange provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) NotifyStatusChange(ctx context.Context, uin uint32, status uint32) error {
	ret := _mock.Called(ctx, uin, status)

	if len(ret) == 0 {
		panic("no return value specified for NotifyStatusChange")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, uint32) error); ok {
		r0 = returnFunc(ctx, uin, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_NotifyStatusChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyStatusChange'
type mockLegacyService_NotifyStatusChange_Call struct {
	*mock.Call
}

// NotifyStatusChange is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - status uint32
func (_e *mockLegacyService_Expecter) NotifyStatusChange(ctx interface{}, uin interface{}, status interface{}) *mockLegacyService_NotifyStatusChange_Call {
	return &mockLegacyService_NotifyStatusChange_Call{Call: _e.mock.On("NotifyStatusChange", ctx, uin, status)}
}

func (_c *mockLegacyService_NotifyStatusChange_Call) Run(run func(ctx context.Context, uin uint32, status uint32)) *mockLegacyService_NotifyStatusChange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 uint32
		if args[2] != nil {
			arg2 = args[2].(uint32)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_NotifyStatusChange_Call) Return(err error) *mockLegacyService_NotifyStatusChange_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_NotifyStatusChange_Call) RunAndReturn(run func(ctx context.Context, uin uint32, status uint32) error) *mockLegacyService_NotifyStatusChange_Call {
	_c.Call.Return(run)
	return _c
}

// NotifyUserOffline provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) NotifyUserOffline(ctx context.Context, uin uint32) error {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for NotifyUserOffline")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) error); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_NotifyUserOffline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyUserOffline'
type mockLegacyService_NotifyUserOffline_Call struct {
	*mock.Call
}

// NotifyUserOffline is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) NotifyUserOffline(ctx interface{}, uin interface{}) *mockLegacyService_NotifyUserOffline_Call {
	return &mockLegacyService_NotifyUserOffline_Call{Call: _e.mock.On("NotifyUserOffline", ctx, uin)}
}

func (_c *mockLegacyService_NotifyUserOffline_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_NotifyUserOffline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_NotifyUserOffline_Call) Return(err error) *mockLegacyService_NotifyUserOffline_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_NotifyUserOffline_Call) RunAndReturn(run func(ctx context.Context, uin uint32) error) *mockLegacyService_NotifyUserOffline_Call {
	_c.Call.Return(run)
	return _c
}

// NotifyUserOnline provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) NotifyUserOnline(ctx context.Context, uin uint32, status uint32) error {
	ret := _mock.Called(ctx, uin, status)

	if len(ret) == 0 {
		panic("no return value specified for NotifyUserOnline")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, uint32) error); ok {
		r0 = returnFunc(ctx, uin, status)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_NotifyUserOnline_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyUserOnline'
type mockLegacyService_NotifyUserOnline_Call struct {
	*mock.Call
}

// NotifyUserOnline is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - status uint32
func (_e *mockLegacyService_Expecter) NotifyUserOnline(ctx interface{}, uin interface{}, status interface{}) *mockLegacyService_NotifyUserOnline_Call {
	return &mockLegacyService_NotifyUserOnline_Call{Call: _e.mock.On("NotifyUserOnline", ctx, uin, status)}
}

func (_c *mockLegacyService_NotifyUserOnline_Call) Run(run func(ctx context.Context, uin uint32, status uint32)) *mockLegacyService_NotifyUserOnline_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 uint32
		if args[2] != nil {
			arg2 = args[2].(uint32)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_NotifyUserOnline_Call) Return(err error) *mockLegacyService_NotifyUserOnline_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_NotifyUserOnline_Call) RunAndReturn(run func(ctx context.Context, uin uint32, status uint32) error) *mockLegacyService_NotifyUserOnline_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessContactList provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) ProcessContactList(ctx context.Context, instance *state.SessionInstance, req ContactListRequest) (*ContactListResult, error) {
	ret := _mock.Called(ctx, instance, req)

	if len(ret) == 0 {
		panic("no return value specified for ProcessContactList")
	}

	var r0 *ContactListResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, ContactListRequest) (*ContactListResult, error)); ok {
		return returnFunc(ctx, instance, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, ContactListRequest) *ContactListResult); ok {
		r0 = returnFunc(ctx, instance, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*ContactListResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *state.SessionInstance, ContactListRequest) error); ok {
		r1 = returnFunc(ctx, instance, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_ProcessContactList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessContactList'
type mockLegacyService_ProcessContactList_Call struct {
	*mock.Call
}

// ProcessContactList is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - req ContactListRequest
func (_e *mockLegacyService_Expecter) ProcessContactList(ctx interface{}, instance interface{}, req interface{}) *mockLegacyService_ProcessContactList_Call {
	return &mockLegacyService_ProcessContactList_Call{Call: _e.mock.On("ProcessContactList", ctx, instance, req)}
}

func (_c *mockLegacyService_ProcessContactList_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, req ContactListRequest)) *mockLegacyService_ProcessContactList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 ContactListRequest
		if args[2] != nil {
			arg2 = args[2].(ContactListRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_ProcessContactList_Call) Return(contactListResult *ContactListResult, err error) *mockLegacyService_ProcessContactList_Call {
	_c.Call.Return(contactListResult, err)
	return _c
}

func (_c *mockLegacyService_ProcessContactList_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, req ContactListRequest) (*ContactListResult, error)) *mockLegacyService_ProcessContactList_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessMessage provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) ProcessMessage(ctx context.Context, session *LegacySession, req MessageRequest) (*MessageResult, error) {
	ret := _mock.Called(ctx, session, req)

	if len(ret) == 0 {
		panic("no return value specified for ProcessMessage")
	}

	var r0 *MessageResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *LegacySession, MessageRequest) (*MessageResult, error)); ok {
		return returnFunc(ctx, session, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *LegacySession, MessageRequest) *MessageResult); ok {
		r0 = returnFunc(ctx, session, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*MessageResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *LegacySession, MessageRequest) error); ok {
		r1 = returnFunc(ctx, session, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_ProcessMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessMessage'
type mockLegacyService_ProcessMessage_Call struct {
	*mock.Call
}

// ProcessMessage is a helper method to define mock.On call
//   - ctx context.Context
//   - session *LegacySession
//   - req MessageRequest
func (_e *mockLegacyService_Expecter) ProcessMessage(ctx interface{}, session interface{}, req interface{}) *mockLegacyService_ProcessMessage_Call {
	return &mockLegacyService_ProcessMessage_Call{Call: _e.mock.On("ProcessMessage", ctx, session, req)}
}

func (_c *mockLegacyService_ProcessMessage_Call) Run(run func(ctx context.Context, session *LegacySession, req MessageRequest)) *mockLegacyService_ProcessMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *LegacySession
		if args[1] != nil {
			arg1 = args[1].(*LegacySession)
		}
		var arg2 MessageRequest
		if args[2] != nil {
			arg2 = args[2].(MessageRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_ProcessMessage_Call) Return(messageResult *MessageResult, err error) *mockLegacyService_ProcessMessage_Call {
	_c.Call.Return(messageResult, err)
	return _c
}

func (_c *mockLegacyService_ProcessMessage_Call) RunAndReturn(run func(ctx context.Context, session *LegacySession, req MessageRequest) (*MessageResult, error)) *mockLegacyService_ProcessMessage_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessStatusChange provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) ProcessStatusChange(ctx context.Context, req StatusChangeRequest) (*StatusChangeResult, error) {
	ret := _mock.Called(ctx, req)

	if len(ret) == 0 {
		panic("no return value specified for ProcessStatusChange")
	}

	var r0 *StatusChangeResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, StatusChangeRequest) (*StatusChangeResult, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, StatusChangeRequest) *StatusChangeResult); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*StatusChangeResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, StatusChangeRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_ProcessStatusChange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessStatusChange'
type mockLegacyService_ProcessStatusChange_Call struct {
	*mock.Call
}

// ProcessStatusChange is a helper method to define mock.On call
//   - ctx context.Context
//   - req StatusChangeRequest
func (_e *mockLegacyService_Expecter) ProcessStatusChange(ctx interface{}, req interface{}) *mockLegacyService_ProcessStatusChange_Call {
	return &mockLegacyService_ProcessStatusChange_Call{Call: _e.mock.On("ProcessStatusChange", ctx, req)}
}

func (_c *mockLegacyService_ProcessStatusChange_Call) Run(run func(ctx context.Context, req StatusChangeRequest)) *mockLegacyService_ProcessStatusChange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 StatusChangeRequest
		if args[1] != nil {
			arg1 = args[1].(StatusChangeRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_ProcessStatusChange_Call) Return(statusChangeResult *StatusChangeResult, err error) *mockLegacyService_ProcessStatusChange_Call {
	_c.Call.Return(statusChangeResult, err)
	return _c
}

func (_c *mockLegacyService_ProcessStatusChange_Call) RunAndReturn(run func(ctx context.Context, req StatusChangeRequest) (*StatusChangeResult, error)) *mockLegacyService_ProcessStatusChange_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessUserAdd provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) ProcessUserAdd(ctx context.Context, instance *state.SessionInstance, req UserAddRequest) (*UserAddResult, error) {
	ret := _mock.Called(ctx, instance, req)

	if len(ret) == 0 {
		panic("no return value specified for ProcessUserAdd")
	}

	var r0 *UserAddResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, UserAddRequest) (*UserAddResult, error)); ok {
		return returnFunc(ctx, instance, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, UserAddRequest) *UserAddResult); ok {
		r0 = returnFunc(ctx, instance, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*UserAddResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *state.SessionInstance, UserAddRequest) error); ok {
		r1 = returnFunc(ctx, instance, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_ProcessUserAdd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessUserAdd'
type mockLegacyService_ProcessUserAdd_Call struct {
	*mock.Call
}

// ProcessUserAdd is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - req UserAddRequest
func (_e *mockLegacyService_Expecter) ProcessUserAdd(ctx interface{}, instance interface{}, req interface{}) *mockLegacyService_ProcessUserAdd_Call {
	return &mockLegacyService_ProcessUserAdd_Call{Call: _e.mock.On("ProcessUserAdd", ctx, instance, req)}
}

func (_c *mockLegacyService_ProcessUserAdd_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, req UserAddRequest)) *mockLegacyService_ProcessUserAdd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 UserAddRequest
		if args[2] != nil {
			arg2 = args[2].(UserAddRequest)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_ProcessUserAdd_Call) Return(userAddResult *UserAddResult, err error) *mockLegacyService_ProcessUserAdd_Call {
	_c.Call.Return(userAddResult, err)
	return _c
}

func (_c *mockLegacyService_ProcessUserAdd_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, req UserAddRequest) (*UserAddResult, error)) *mockLegacyService_ProcessUserAdd_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterNewUser provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) RegisterNewUser(ctx context.Context, nickname string, firstName string, lastName string, email string, password string) (uint32, error) {
	ret := _mock.Called(ctx, nickname, firstName, lastName, email, password)

	if len(ret) == 0 {
		panic("no return value specified for RegisterNewUser")
	}

	var r0 uint32
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) (uint32, error)); ok {
		return returnFunc(ctx, nickname, firstName, lastName, email, password)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string, string) uint32); ok {
		r0 = returnFunc(ctx, nickname, firstName, lastName, email, password)
	} else {
		r0 = ret.Get(0).(uint32)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, nickname, firstName, lastName, email, password)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_RegisterNewUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RegisterNewUser'
type mockLegacyService_RegisterNewUser_Call struct {
	*mock.Call
}

// RegisterNewUser is a helper method to define mock.On call
//   - ctx context.Context
//   - nickname string
//   - firstName string
//   - lastName string
//   - email string
//   - password string
func (_e *mockLegacyService_Expecter) RegisterNewUser(ctx interface{}, nickname interface{}, firstName interface{}, lastName interface{}, email interface{}, password interface{}) *mockLegacyService_RegisterNewUser_Call {
	return &mockLegacyService_RegisterNewUser_Call{Call: _e.mock.On("RegisterNewUser", ctx, nickname, firstName, lastName, email, password)}
}

func (_c *mockLegacyService_RegisterNewUser_Call) Run(run func(ctx context.Context, nickname string, firstName string, lastName string, email string, password string)) *mockLegacyService_RegisterNewUser_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		var arg5 string
		if args[5] != nil {
			arg5 = args[5].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
			arg5,
		)
	})
	return _c
}

func (_c *mockLegacyService_RegisterNewUser_Call) Return(v uint32, err error) *mockLegacyService_RegisterNewUser_Call {
	_c.Call.Return(v, err)
	return _c
}

func (_c *mockLegacyService_RegisterNewUser_Call) RunAndReturn(run func(ctx context.Context, nickname string, firstName string, lastName string, email string, password string) (uint32, error)) *mockLegacyService_RegisterNewUser_Call {
	_c.Call.Return(run)
	return _c
}

// SearchByName provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SearchByName(ctx context.Context, nick string, first string, last string, email string) ([]LegacyUserSearchResult, error) {
	ret := _mock.Called(ctx, nick, first, last, email)

	if len(ret) == 0 {
		panic("no return value specified for SearchByName")
	}

	var r0 []LegacyUserSearchResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) ([]LegacyUserSearchResult, error)); ok {
		return returnFunc(ctx, nick, first, last, email)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) []LegacyUserSearchResult); ok {
		r0 = returnFunc(ctx, nick, first, last, email)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]LegacyUserSearchResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string, string) error); ok {
		r1 = returnFunc(ctx, nick, first, last, email)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_SearchByName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchByName'
type mockLegacyService_SearchByName_Call struct {
	*mock.Call
}

// SearchByName is a helper method to define mock.On call
//   - ctx context.Context
//   - nick string
//   - first string
//   - last string
//   - email string
func (_e *mockLegacyService_Expecter) SearchByName(ctx interface{}, nick interface{}, first interface{}, last interface{}, email interface{}) *mockLegacyService_SearchByName_Call {
	return &mockLegacyService_SearchByName_Call{Call: _e.mock.On("SearchByName", ctx, nick, first, last, email)}
}

func (_c *mockLegacyService_SearchByName_Call) Run(run func(ctx context.Context, nick string, first string, last string, email string)) *mockLegacyService_SearchByName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		var arg4 string
		if args[4] != nil {
			arg4 = args[4].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

func (_c *mockLegacyService_SearchByName_Call) Return(legacyUserSearchResults []LegacyUserSearchResult, err error) *mockLegacyService_SearchByName_Call {
	_c.Call.Return(legacyUserSearchResults, err)
	return _c
}

func (_c *mockLegacyService_SearchByName_Call) RunAndReturn(run func(ctx context.Context, nick string, first string, last string, email string) ([]LegacyUserSearchResult, error)) *mockLegacyService_SearchByName_Call {
	_c.Call.Return(run)
	return _c
}

// SearchByUIN provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SearchByUIN(ctx context.Context, uin uint32) (*LegacyUserSearchResult, error) {
	ret := _mock.Called(ctx, uin)

	if len(ret) == 0 {
		panic("no return value specified for SearchByUIN")
	}

	var r0 *LegacyUserSearchResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) (*LegacyUserSearchResult, error)); ok {
		return returnFunc(ctx, uin)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32) *LegacyUserSearchResult); ok {
		r0 = returnFunc(ctx, uin)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*LegacyUserSearchResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32) error); ok {
		r1 = returnFunc(ctx, uin)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_SearchByUIN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchByUIN'
type mockLegacyService_SearchByUIN_Call struct {
	*mock.Call
}

// SearchByUIN is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
func (_e *mockLegacyService_Expecter) SearchByUIN(ctx interface{}, uin interface{}) *mockLegacyService_SearchByUIN_Call {
	return &mockLegacyService_SearchByUIN_Call{Call: _e.mock.On("SearchByUIN", ctx, uin)}
}

func (_c *mockLegacyService_SearchByUIN_Call) Run(run func(ctx context.Context, uin uint32)) *mockLegacyService_SearchByUIN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_SearchByUIN_Call) Return(legacyUserSearchResult *LegacyUserSearchResult, err error) *mockLegacyService_SearchByUIN_Call {
	_c.Call.Return(legacyUserSearchResult, err)
	return _c
}

func (_c *mockLegacyService_SearchByUIN_Call) RunAndReturn(run func(ctx context.Context, uin uint32) (*LegacyUserSearchResult, error)) *mockLegacyService_SearchByUIN_Call {
	_c.Call.Return(run)
	return _c
}

// SetAffiliations provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SetAffiliations(ctx context.Context, uin uint32, affiliations state.ICQAffiliations) error {
	ret := _mock.Called(ctx, uin, affiliations)

	if len(ret) == 0 {
		panic("no return value specified for SetAffiliations")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQAffiliations) error); ok {
		r0 = returnFunc(ctx, uin, affiliations)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_SetAffiliations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAffiliations'
type mockLegacyService_SetAffiliations_Call struct {
	*mock.Call
}

// SetAffiliations is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - affiliations state.ICQAffiliations
func (_e *mockLegacyService_Expecter) SetAffiliations(ctx interface{}, uin interface{}, affiliations interface{}) *mockLegacyService_SetAffiliations_Call {
	return &mockLegacyService_SetAffiliations_Call{Call: _e.mock.On("SetAffiliations", ctx, uin, affiliations)}
}

func (_c *mockLegacyService_SetAffiliations_Call) Run(run func(ctx context.Context, uin uint32, affiliations state.ICQAffiliations)) *mockLegacyService_SetAffiliations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQAffiliations
		if args[2] != nil {
			arg2 = args[2].(state.ICQAffiliations)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_SetAffiliations_Call) Return(err error) *mockLegacyService_SetAffiliations_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_SetAffiliations_Call) RunAndReturn(run func(ctx context.Context, uin uint32, affiliations state.ICQAffiliations) error) *mockLegacyService_SetAffiliations_Call {
	_c.Call.Return(run)
	return _c
}

// SetAuthMode provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SetAuthMode(ctx context.Context, uin uint32, authRequired bool) error {
	ret := _mock.Called(ctx, uin, authRequired)

	if len(ret) == 0 {
		panic("no return value specified for SetAuthMode")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, bool) error); ok {
		r0 = returnFunc(ctx, uin, authRequired)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_SetAuthMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetAuthMode'
type mockLegacyService_SetAuthMode_Call struct {
	*mock.Call
}

// SetAuthMode is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - authRequired bool
func (_e *mockLegacyService_Expecter) SetAuthMode(ctx interface{}, uin interface{}, authRequired interface{}) *mockLegacyService_SetAuthMode_Call {
	return &mockLegacyService_SetAuthMode_Call{Call: _e.mock.On("SetAuthMode", ctx, uin, authRequired)}
}

func (_c *mockLegacyService_SetAuthMode_Call) Run(run func(ctx context.Context, uin uint32, authRequired bool)) *mockLegacyService_SetAuthMode_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 bool
		if args[2] != nil {
			arg2 = args[2].(bool)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_SetAuthMode_Call) Return(err error) *mockLegacyService_SetAuthMode_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_SetAuthMode_Call) RunAndReturn(run func(ctx context.Context, uin uint32, authRequired bool) error) *mockLegacyService_SetAuthMode_Call {
	_c.Call.Return(run)
	return _c
}

// SetHomepageCategory provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SetHomepageCategory(ctx context.Context, uin uint32, hpcat state.ICQHomepageCategory) error {
	ret := _mock.Called(ctx, uin, hpcat)

	if len(ret) == 0 {
		panic("no return value specified for SetHomepageCategory")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQHomepageCategory) error); ok {
		r0 = returnFunc(ctx, uin, hpcat)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_SetHomepageCategory_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetHomepageCategory'
type mockLegacyService_SetHomepageCategory_Call struct {
	*mock.Call
}

// SetHomepageCategory is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - hpcat state.ICQHomepageCategory
func (_e *mockLegacyService_Expecter) SetHomepageCategory(ctx interface{}, uin interface{}, hpcat interface{}) *mockLegacyService_SetHomepageCategory_Call {
	return &mockLegacyService_SetHomepageCategory_Call{Call: _e.mock.On("SetHomepageCategory", ctx, uin, hpcat)}
}

func (_c *mockLegacyService_SetHomepageCategory_Call) Run(run func(ctx context.Context, uin uint32, hpcat state.ICQHomepageCategory)) *mockLegacyService_SetHomepageCategory_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQHomepageCategory
		if args[2] != nil {
			arg2 = args[2].(state.ICQHomepageCategory)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_SetHomepageCategory_Call) Return(err error) *mockLegacyService_SetHomepageCategory_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_SetHomepageCategory_Call) RunAndReturn(run func(ctx context.Context, uin uint32, hpcat state.ICQHomepageCategory) error) *mockLegacyService_SetHomepageCategory_Call {
	_c.Call.Return(run)
	return _c
}

// SetInterests provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SetInterests(ctx context.Context, uin uint32, interests state.ICQInterests) error {
	ret := _mock.Called(ctx, uin, interests)

	if len(ret) == 0 {
		panic("no return value specified for SetInterests")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQInterests) error); ok {
		r0 = returnFunc(ctx, uin, interests)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_SetInterests_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetInterests'
type mockLegacyService_SetInterests_Call struct {
	*mock.Call
}

// SetInterests is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - interests state.ICQInterests
func (_e *mockLegacyService_Expecter) SetInterests(ctx interface{}, uin interface{}, interests interface{}) *mockLegacyService_SetInterests_Call {
	return &mockLegacyService_SetInterests_Call{Call: _e.mock.On("SetInterests", ctx, uin, interests)}
}

func (_c *mockLegacyService_SetInterests_Call) Run(run func(ctx context.Context, uin uint32, interests state.ICQInterests)) *mockLegacyService_SetInterests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQInterests
		if args[2] != nil {
			arg2 = args[2].(state.ICQInterests)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_SetInterests_Call) Return(err error) *mockLegacyService_SetInterests_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_SetInterests_Call) RunAndReturn(run func(ctx context.Context, uin uint32, interests state.ICQInterests) error) *mockLegacyService_SetInterests_Call {
	_c.Call.Return(run)
	return _c
}

// SetNotes provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SetNotes(ctx context.Context, uin uint32, notes string) error {
	ret := _mock.Called(ctx, uin, notes)

	if len(ret) == 0 {
		panic("no return value specified for SetNotes")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, string) error); ok {
		r0 = returnFunc(ctx, uin, notes)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_SetNotes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetNotes'
type mockLegacyService_SetNotes_Call struct {
	*mock.Call
}

// SetNotes is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - notes string
func (_e *mockLegacyService_Expecter) SetNotes(ctx interface{}, uin interface{}, notes interface{}) *mockLegacyService_SetNotes_Call {
	return &mockLegacyService_SetNotes_Call{Call: _e.mock.On("SetNotes", ctx, uin, notes)}
}

func (_c *mockLegacyService_SetNotes_Call) Run(run func(ctx context.Context, uin uint32, notes string)) *mockLegacyService_SetNotes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_SetNotes_Call) Return(err error) *mockLegacyService_SetNotes_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_SetNotes_Call) RunAndReturn(run func(ctx context.Context, uin uint32, notes string) error) *mockLegacyService_SetNotes_Call {
	_c.Call.Return(run)
	return _c
}

// SetPassword provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) SetPassword(ctx context.Context, uin uint32, oldPassword string, newPassword string) error {
	ret := _mock.Called(ctx, uin, oldPassword, newPassword)

	if len(ret) == 0 {
		panic("no return value specified for SetPassword")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, string, string) error); ok {
		r0 = returnFunc(ctx, uin, oldPassword, newPassword)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_SetPassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPassword'
type mockLegacyService_SetPassword_Call struct {
	*mock.Call
}

// SetPassword is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - oldPassword string
//   - newPassword string
func (_e *mockLegacyService_Expecter) SetPassword(ctx interface{}, uin interface{}, oldPassword interface{}, newPassword interface{}) *mockLegacyService_SetPassword_Call {
	return &mockLegacyService_SetPassword_Call{Call: _e.mock.On("SetPassword", ctx, uin, oldPassword, newPassword)}
}

func (_c *mockLegacyService_SetPassword_Call) Run(run func(ctx context.Context, uin uint32, oldPassword string, newPassword string)) *mockLegacyService_SetPassword_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		var arg3 string
		if args[3] != nil {
			arg3 = args[3].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *mockLegacyService_SetPassword_Call) Return(err error) *mockLegacyService_SetPassword_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_SetPassword_Call) RunAndReturn(run func(ctx context.Context, uin uint32, oldPassword string, newPassword string) error) *mockLegacyService_SetPassword_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateBasicInfo provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) UpdateBasicInfo(ctx context.Context, uin uint32, info state.ICQBasicInfo) error {
	ret := _mock.Called(ctx, uin, info)

	if len(ret) == 0 {
		panic("no return value specified for UpdateBasicInfo")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQBasicInfo) error); ok {
		r0 = returnFunc(ctx, uin, info)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_UpdateBasicInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateBasicInfo'
type mockLegacyService_UpdateBasicInfo_Call struct {
	*mock.Call
}

// UpdateBasicInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - info state.ICQBasicInfo
func (_e *mockLegacyService_Expecter) UpdateBasicInfo(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdateBasicInfo_Call {
	return &mockLegacyService_UpdateBasicInfo_Call{Call: _e.mock.On("UpdateBasicInfo", ctx, uin, info)}
}

func (_c *mockLegacyService_UpdateBasicInfo_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQBasicInfo)) *mockLegacyService_UpdateBasicInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQBasicInfo
		if args[2] != nil {
			arg2 = args[2].(state.ICQBasicInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_UpdateBasicInfo_Call) Return(err error) *mockLegacyService_UpdateBasicInfo_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_UpdateBasicInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQBasicInfo) error) *mockLegacyService_UpdateBasicInfo_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateMoreInfo provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) UpdateMoreInfo(ctx context.Context, uin uint32, info state.ICQMoreInfo) error {
	ret := _mock.Called(ctx, uin, info)

	if len(ret) == 0 {
		panic("no return value specified for UpdateMoreInfo")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQMoreInfo) error); ok {
		r0 = returnFunc(ctx, uin, info)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_UpdateMoreInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateMoreInfo'
type mockLegacyService_UpdateMoreInfo_Call struct {
	*mock.Call
}

// UpdateMoreInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - info state.ICQMoreInfo
func (_e *mockLegacyService_Expecter) UpdateMoreInfo(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdateMoreInfo_Call {
	return &mockLegacyService_UpdateMoreInfo_Call{Call: _e.mock.On("UpdateMoreInfo", ctx, uin, info)}
}

func (_c *mockLegacyService_UpdateMoreInfo_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQMoreInfo)) *mockLegacyService_UpdateMoreInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQMoreInfo
		if args[2] != nil {
			arg2 = args[2].(state.ICQMoreInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_UpdateMoreInfo_Call) Return(err error) *mockLegacyService_UpdateMoreInfo_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_UpdateMoreInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQMoreInfo) error) *mockLegacyService_UpdateMoreInfo_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePermissions provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) UpdatePermissions(ctx context.Context, uin uint32, info state.ICQPermissions) error {
	ret := _mock.Called(ctx, uin, info)

	if len(ret) == 0 {
		panic("no return value specified for UpdatePermissions")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQPermissions) error); ok {
		r0 = returnFunc(ctx, uin, info)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_UpdatePermissions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePermissions'
type mockLegacyService_UpdatePermissions_Call struct {
	*mock.Call
}

// UpdatePermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - info state.ICQPermissions
func (_e *mockLegacyService_Expecter) UpdatePermissions(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdatePermissions_Call {
	return &mockLegacyService_UpdatePermissions_Call{Call: _e.mock.On("UpdatePermissions", ctx, uin, info)}
}

func (_c *mockLegacyService_UpdatePermissions_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQPermissions)) *mockLegacyService_UpdatePermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQPermissions
		if args[2] != nil {
			arg2 = args[2].(state.ICQPermissions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_UpdatePermissions_Call) Return(err error) *mockLegacyService_UpdatePermissions_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_UpdatePermissions_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQPermissions) error) *mockLegacyService_UpdatePermissions_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateWorkInfo provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) UpdateWorkInfo(ctx context.Context, uin uint32, info state.ICQWorkInfo) error {
	ret := _mock.Called(ctx, uin, info)

	if len(ret) == 0 {
		panic("no return value specified for UpdateWorkInfo")
	}

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, state.ICQWorkInfo) error); ok {
		r0 = returnFunc(ctx, uin, info)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

// mockLegacyService_UpdateWorkInfo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkInfo'
type mockLegacyService_UpdateWorkInfo_Call struct {
	*mock.Call
}

// UpdateWorkInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - info state.ICQWorkInfo
func (_e *mockLegacyService_Expecter) UpdateWorkInfo(ctx interface{}, uin interface{}, info interface{}) *mockLegacyService_UpdateWorkInfo_Call {
	return &mockLegacyService_UpdateWorkInfo_Call{Call: _e.mock.On("UpdateWorkInfo", ctx, uin, info)}
}

func (_c *mockLegacyService_UpdateWorkInfo_Call) Run(run func(ctx context.Context, uin uint32, info state.ICQWorkInfo)) *mockLegacyService_UpdateWorkInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 state.ICQWorkInfo
		if args[2] != nil {
			arg2 = args[2].(state.ICQWorkInfo)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_UpdateWorkInfo_Call) Return(err error) *mockLegacyService_UpdateWorkInfo_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *mockLegacyService_UpdateWorkInfo_Call) RunAndReturn(run func(ctx context.Context, uin uint32, info state.ICQWorkInfo) error) *mockLegacyService_UpdateWorkInfo_Call {
	_c.Call.Return(run)
	return _c
}

// ValidateCredentials provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) ValidateCredentials(ctx context.Context, uin uint32, password string) (bool, error) {
	ret := _mock.Called(ctx, uin, password)

	if len(ret) == 0 {
		panic("no return value specified for ValidateCredentials")
	}

	var r0 bool
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, string) (bool, error)); ok {
		return returnFunc(ctx, uin, password)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, uint32, string) bool); ok {
		r0 = returnFunc(ctx, uin, password)
	} else {
		r0 = ret.Get(0).(bool)
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, uint32, string) error); ok {
		r1 = returnFunc(ctx, uin, password)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_ValidateCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateCredentials'
type mockLegacyService_ValidateCredentials_Call struct {
	*mock.Call
}

// ValidateCredentials is a helper method to define mock.On call
//   - ctx context.Context
//   - uin uint32
//   - password string
func (_e *mockLegacyService_Expecter) ValidateCredentials(ctx interface{}, uin interface{}, password interface{}) *mockLegacyService_ValidateCredentials_Call {
	return &mockLegacyService_ValidateCredentials_Call{Call: _e.mock.On("ValidateCredentials", ctx, uin, password)}
}

func (_c *mockLegacyService_ValidateCredentials_Call) Run(run func(ctx context.Context, uin uint32, password string)) *mockLegacyService_ValidateCredentials_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 uint32
		if args[1] != nil {
			arg1 = args[1].(uint32)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *mockLegacyService_ValidateCredentials_Call) Return(b bool, err error) *mockLegacyService_ValidateCredentials_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *mockLegacyService_ValidateCredentials_Call) RunAndReturn(run func(ctx context.Context, uin uint32, password string) (bool, error)) *mockLegacyService_ValidateCredentials_Call {
	_c.Call.Return(run)
	return _c
}

// WhitePagesSearch provides a mock function for the type mockLegacyService
func (_mock *mockLegacyService) WhitePagesSearch(ctx context.Context, criteria WhitePagesSearchCriteria) ([]LegacyUserSearchResult, error) {
	ret := _mock.Called(ctx, criteria)

	if len(ret) == 0 {
		panic("no return value specified for WhitePagesSearch")
	}

	var r0 []LegacyUserSearchResult
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, WhitePagesSearchCriteria) ([]LegacyUserSearchResult, error)); ok {
		return returnFunc(ctx, criteria)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, WhitePagesSearchCriteria) []LegacyUserSearchResult); ok {
		r0 = returnFunc(ctx, criteria)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]LegacyUserSearchResult)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, WhitePagesSearchCriteria) error); ok {
		r1 = returnFunc(ctx, criteria)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// mockLegacyService_WhitePagesSearch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WhitePagesSearch'
type mockLegacyService_WhitePagesSearch_Call struct {
	*mock.Call
}

// WhitePagesSearch is a helper method to define mock.On call
//   - ctx context.Context
//   - criteria WhitePagesSearchCriteria
func (_e *mockLegacyService_Expecter) WhitePagesSearch(ctx interface{}, criteria interface{}) *mockLegacyService_WhitePagesSearch_Call {
	return &mockLegacyService_WhitePagesSearch_Call{Call: _e.mock.On("WhitePagesSearch", ctx, criteria)}
}

func (_c *mockLegacyService_WhitePagesSearch_Call) Run(run func(ctx context.Context, criteria WhitePagesSearchCriteria)) *mockLegacyService_WhitePagesSearch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 WhitePagesSearchCriteria
		if args[1] != nil {
			arg1 = args[1].(WhitePagesSearchCriteria)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *mockLegacyService_WhitePagesSearch_Call) Return(legacyUserSearchResults []LegacyUserSearchResult, err error) *mockLegacyService_WhitePagesSearch_Call {
	_c.Call.Return(legacyUserSearchResults, err)
	return _c
}

func (_c *mockLegacyService_WhitePagesSearch_Call) RunAndReturn(run func(ctx context.Context, criteria WhitePagesSearchCriteria) ([]LegacyUserSearchResult, error)) *mockLegacyService_WhitePagesSearch_Call {
	_c.Call.Return(run)
	return _c
}