// Code generated by mockery v2.50.0. DO NOT EDIT.

package mocks

import (
	context "context"

	api "github.com/heroiclabs/nakama-common/api"

	http "net/http"

	mock "github.com/stretchr/testify/mock"

	rtapi "github.com/heroiclabs/nakama-common/rtapi"

	runtime "github.com/heroiclabs/nakama-common/runtime"

	sql "database/sql"
)

// MockInitializer is an autogenerated mock type for the Initializer type
type MockInitializer struct {
	mock.Mock
}

type MockInitializer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockInitializer) EXPECT() *MockInitializer_Expecter {
	return &MockInitializer_Expecter{mock: &_m.Mock}
}

// GetConfig provides a mock function with no fields
func (_m *MockInitializer) GetConfig() (runtime.Config, error) {
	ret := _m.Called()

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

	var r0 runtime.Config
	var r1 error
	if rf, ok := ret.Get(0).(func() (runtime.Config, error)); ok {
		return rf()
	}
	if rf, ok := ret.Get(0).(func() runtime.Config); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(runtime.Config)
		}
	}

	if rf, ok := ret.Get(1).(func() error); ok {
		r1 = rf()
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetConfig is a helper method to define mock.On call
func (_e *MockInitializer_Expecter) GetConfig() *MockInitializer_GetConfig_Call {
	return &MockInitializer_GetConfig_Call{Call: _e.mock.On("GetConfig")}
}

func (_c *MockInitializer_GetConfig_Call) Run(run func()) *MockInitializer_GetConfig_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockInitializer_GetConfig_Call) Return(_a0 runtime.Config, _a1 error) *MockInitializer_GetConfig_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockInitializer_GetConfig_Call) RunAndReturn(run func() (runtime.Config, error)) *MockInitializer_GetConfig_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAddFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAddFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAddFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddFriendsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAddFriends(fn interface{}) *MockInitializer_RegisterAfterAddFriends_Call {
	return &MockInitializer_RegisterAfterAddFriends_Call{Call: _e.mock.On("RegisterAfterAddFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterAddFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error)) *MockInitializer_RegisterAfterAddFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAddFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterAddFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAddFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) error) error) *MockInitializer_RegisterAfterAddFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAddGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAddGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAddGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddGroupUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAddGroupUsers(fn interface{}) *MockInitializer_RegisterAfterAddGroupUsers_Call {
	return &MockInitializer_RegisterAfterAddGroupUsers_Call{Call: _e.mock.On("RegisterAfterAddGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterAddGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error)) *MockInitializer_RegisterAfterAddGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAddGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterAddGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAddGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) error) error) *MockInitializer_RegisterAfterAddGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateAppleRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateApple(fn interface{}) *MockInitializer_RegisterAfterAuthenticateApple_Call {
	return &MockInitializer_RegisterAfterAuthenticateApple_Call{Call: _e.mock.On("RegisterAfterAuthenticateApple", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error)) *MockInitializer_RegisterAfterAuthenticateApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateAppleRequest) error) error) *MockInitializer_RegisterAfterAuthenticateApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateCustom provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateCustom is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateCustomRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateCustom(fn interface{}) *MockInitializer_RegisterAfterAuthenticateCustom_Call {
	return &MockInitializer_RegisterAfterAuthenticateCustom_Call{Call: _e.mock.On("RegisterAfterAuthenticateCustom", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error)) *MockInitializer_RegisterAfterAuthenticateCustom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateCustom_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateCustom_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateCustomRequest) error) error) *MockInitializer_RegisterAfterAuthenticateCustom_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateDevice provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateDevice is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateDeviceRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateDevice(fn interface{}) *MockInitializer_RegisterAfterAuthenticateDevice_Call {
	return &MockInitializer_RegisterAfterAuthenticateDevice_Call{Call: _e.mock.On("RegisterAfterAuthenticateDevice", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error)) *MockInitializer_RegisterAfterAuthenticateDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateDevice_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateDeviceRequest) error) error) *MockInitializer_RegisterAfterAuthenticateDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateEmail provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateEmail is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateEmailRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateEmail(fn interface{}) *MockInitializer_RegisterAfterAuthenticateEmail_Call {
	return &MockInitializer_RegisterAfterAuthenticateEmail_Call{Call: _e.mock.On("RegisterAfterAuthenticateEmail", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error)) *MockInitializer_RegisterAfterAuthenticateEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateEmail_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateEmail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateEmailRequest) error) error) *MockInitializer_RegisterAfterAuthenticateEmail_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateFacebook provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateFacebook is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateFacebookRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateFacebook(fn interface{}) *MockInitializer_RegisterAfterAuthenticateFacebook_Call {
	return &MockInitializer_RegisterAfterAuthenticateFacebook_Call{Call: _e.mock.On("RegisterAfterAuthenticateFacebook", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error)) *MockInitializer_RegisterAfterAuthenticateFacebook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateFacebook_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateFacebook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookRequest) error) error) *MockInitializer_RegisterAfterAuthenticateFacebook_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateFacebookInstantGame provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateFacebookInstantGame is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateFacebookInstantGameRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateFacebookInstantGame(fn interface{}) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call {
	return &MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call{Call: _e.mock.On("RegisterAfterAuthenticateFacebookInstantGame", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error)) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateFacebookInstantGameRequest) error) error) *MockInitializer_RegisterAfterAuthenticateFacebookInstantGame_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateGameCenter provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateGameCenter is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateGameCenterRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateGameCenter(fn interface{}) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call {
	return &MockInitializer_RegisterAfterAuthenticateGameCenter_Call{Call: _e.mock.On("RegisterAfterAuthenticateGameCenter", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error)) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGameCenterRequest) error) error) *MockInitializer_RegisterAfterAuthenticateGameCenter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateGoogleRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateGoogle(fn interface{}) *MockInitializer_RegisterAfterAuthenticateGoogle_Call {
	return &MockInitializer_RegisterAfterAuthenticateGoogle_Call{Call: _e.mock.On("RegisterAfterAuthenticateGoogle", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error)) *MockInitializer_RegisterAfterAuthenticateGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateGoogleRequest) error) error) *MockInitializer_RegisterAfterAuthenticateGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterAuthenticateSteam provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterAuthenticateSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterAuthenticateSteam is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.AuthenticateSteamRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterAuthenticateSteam(fn interface{}) *MockInitializer_RegisterAfterAuthenticateSteam_Call {
	return &MockInitializer_RegisterAfterAuthenticateSteam_Call{Call: _e.mock.On("RegisterAfterAuthenticateSteam", fn)}
}

func (_c *MockInitializer_RegisterAfterAuthenticateSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error)) *MockInitializer_RegisterAfterAuthenticateSteam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateSteam_Call) Return(_a0 error) *MockInitializer_RegisterAfterAuthenticateSteam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterAuthenticateSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.AuthenticateSteamRequest) error) error) *MockInitializer_RegisterAfterAuthenticateSteam_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterBanGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterBanGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterBanGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BanGroupUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterBanGroupUsers(fn interface{}) *MockInitializer_RegisterAfterBanGroupUsers_Call {
	return &MockInitializer_RegisterAfterBanGroupUsers_Call{Call: _e.mock.On("RegisterAfterBanGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterBanGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error)) *MockInitializer_RegisterAfterBanGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterBanGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterBanGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterBanGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) error) error) *MockInitializer_RegisterAfterBanGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterBlockFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterBlockFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterBlockFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BlockFriendsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterBlockFriends(fn interface{}) *MockInitializer_RegisterAfterBlockFriends_Call {
	return &MockInitializer_RegisterAfterBlockFriends_Call{Call: _e.mock.On("RegisterAfterBlockFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterBlockFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error)) *MockInitializer_RegisterAfterBlockFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterBlockFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterBlockFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterBlockFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) error) error) *MockInitializer_RegisterAfterBlockFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterCreateGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterCreateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterCreateGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Group , *api.CreateGroupRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterCreateGroup(fn interface{}) *MockInitializer_RegisterAfterCreateGroup_Call {
	return &MockInitializer_RegisterAfterCreateGroup_Call{Call: _e.mock.On("RegisterAfterCreateGroup", fn)}
}

func (_c *MockInitializer_RegisterAfterCreateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error)) *MockInitializer_RegisterAfterCreateGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterCreateGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterCreateGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterCreateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Group, *api.CreateGroupRequest) error) error) *MockInitializer_RegisterAfterCreateGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteAccount provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteAccount is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteAccount(fn interface{}) *MockInitializer_RegisterAfterDeleteAccount_Call {
	return &MockInitializer_RegisterAfterDeleteAccount_Call{Call: _e.mock.On("RegisterAfterDeleteAccount", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterAfterDeleteAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteAccount_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterAfterDeleteAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteFriendsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteFriends(fn interface{}) *MockInitializer_RegisterAfterDeleteFriends_Call {
	return &MockInitializer_RegisterAfterDeleteFriends_Call{Call: _e.mock.On("RegisterAfterDeleteFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error)) *MockInitializer_RegisterAfterDeleteFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) error) error) *MockInitializer_RegisterAfterDeleteFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteGroupRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteGroup(fn interface{}) *MockInitializer_RegisterAfterDeleteGroup_Call {
	return &MockInitializer_RegisterAfterDeleteGroup_Call{Call: _e.mock.On("RegisterAfterDeleteGroup", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error)) *MockInitializer_RegisterAfterDeleteGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) error) error) *MockInitializer_RegisterAfterDeleteGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteLeaderboardRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteLeaderboardRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteLeaderboardRecordRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call {
	return &MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call{Call: _e.mock.On("RegisterAfterDeleteLeaderboardRecord", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error)) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) error) error) *MockInitializer_RegisterAfterDeleteLeaderboardRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteNotifications provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteNotifications is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteNotificationsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteNotifications(fn interface{}) *MockInitializer_RegisterAfterDeleteNotifications_Call {
	return &MockInitializer_RegisterAfterDeleteNotifications_Call{Call: _e.mock.On("RegisterAfterDeleteNotifications", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error)) *MockInitializer_RegisterAfterDeleteNotifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteNotifications_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteNotifications_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) error) error) *MockInitializer_RegisterAfterDeleteNotifications_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteStorageObjectsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteStorageObjects(fn interface{}) *MockInitializer_RegisterAfterDeleteStorageObjects_Call {
	return &MockInitializer_RegisterAfterDeleteStorageObjects_Call{Call: _e.mock.On("RegisterAfterDeleteStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error)) *MockInitializer_RegisterAfterDeleteStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterDeleteStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDeleteTournamentRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDeleteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDeleteTournamentRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteTournamentRecordRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDeleteTournamentRecord(fn interface{}) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call {
	return &MockInitializer_RegisterAfterDeleteTournamentRecord_Call{Call: _e.mock.On("RegisterAfterDeleteTournamentRecord", fn)}
}

func (_c *MockInitializer_RegisterAfterDeleteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error)) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDeleteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) error) error) *MockInitializer_RegisterAfterDeleteTournamentRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterDemoteGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterDemoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterDemoteGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DemoteGroupUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterDemoteGroupUsers(fn interface{}) *MockInitializer_RegisterAfterDemoteGroupUsers_Call {
	return &MockInitializer_RegisterAfterDemoteGroupUsers_Call{Call: _e.mock.On("RegisterAfterDemoteGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterDemoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error)) *MockInitializer_RegisterAfterDemoteGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterDemoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterDemoteGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterDemoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) error) error) *MockInitializer_RegisterAfterDemoteGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterGetAccount provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterGetAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterGetAccount is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Account) error
func (_e *MockInitializer_Expecter) RegisterAfterGetAccount(fn interface{}) *MockInitializer_RegisterAfterGetAccount_Call {
	return &MockInitializer_RegisterAfterGetAccount_Call{Call: _e.mock.On("RegisterAfterGetAccount", fn)}
}

func (_c *MockInitializer_RegisterAfterGetAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error)) *MockInitializer_RegisterAfterGetAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterGetAccount_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterGetAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Account) error) error) *MockInitializer_RegisterAfterGetAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterGetMatchmakerStats provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterGetMatchmakerStats(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterGetMatchmakerStats is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.MatchmakerStats) error
func (_e *MockInitializer_Expecter) RegisterAfterGetMatchmakerStats(fn interface{}) *MockInitializer_RegisterAfterGetMatchmakerStats_Call {
	return &MockInitializer_RegisterAfterGetMatchmakerStats_Call{Call: _e.mock.On("RegisterAfterGetMatchmakerStats", fn)}
}

func (_c *MockInitializer_RegisterAfterGetMatchmakerStats_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error)) *MockInitializer_RegisterAfterGetMatchmakerStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterGetMatchmakerStats_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetMatchmakerStats_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterGetMatchmakerStats_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchmakerStats) error) error) *MockInitializer_RegisterAfterGetMatchmakerStats_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterGetSubscription provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterGetSubscription(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterGetSubscription is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedSubscription , *api.GetSubscriptionRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterGetSubscription(fn interface{}) *MockInitializer_RegisterAfterGetSubscription_Call {
	return &MockInitializer_RegisterAfterGetSubscription_Call{Call: _e.mock.On("RegisterAfterGetSubscription", fn)}
}

func (_c *MockInitializer_RegisterAfterGetSubscription_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error)) *MockInitializer_RegisterAfterGetSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterGetSubscription_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetSubscription_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterGetSubscription_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, *api.GetSubscriptionRequest) error) error) *MockInitializer_RegisterAfterGetSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterGetUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterGetUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterGetUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Users , *api.GetUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterGetUsers(fn interface{}) *MockInitializer_RegisterAfterGetUsers_Call {
	return &MockInitializer_RegisterAfterGetUsers_Call{Call: _e.mock.On("RegisterAfterGetUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterGetUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error)) *MockInitializer_RegisterAfterGetUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterGetUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterGetUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterGetUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Users, *api.GetUsersRequest) error) error) *MockInitializer_RegisterAfterGetUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterImportFacebookFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterImportFacebookFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterImportFacebookFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportFacebookFriendsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterImportFacebookFriends(fn interface{}) *MockInitializer_RegisterAfterImportFacebookFriends_Call {
	return &MockInitializer_RegisterAfterImportFacebookFriends_Call{Call: _e.mock.On("RegisterAfterImportFacebookFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterImportFacebookFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error)) *MockInitializer_RegisterAfterImportFacebookFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterImportFacebookFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterImportFacebookFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterImportFacebookFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) error) error) *MockInitializer_RegisterAfterImportFacebookFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterImportSteamFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterImportSteamFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterImportSteamFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportSteamFriendsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterImportSteamFriends(fn interface{}) *MockInitializer_RegisterAfterImportSteamFriends_Call {
	return &MockInitializer_RegisterAfterImportSteamFriends_Call{Call: _e.mock.On("RegisterAfterImportSteamFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterImportSteamFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error)) *MockInitializer_RegisterAfterImportSteamFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterImportSteamFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterImportSteamFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterImportSteamFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) error) error) *MockInitializer_RegisterAfterImportSteamFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterJoinGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterJoinGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterJoinGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinGroupRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterJoinGroup(fn interface{}) *MockInitializer_RegisterAfterJoinGroup_Call {
	return &MockInitializer_RegisterAfterJoinGroup_Call{Call: _e.mock.On("RegisterAfterJoinGroup", fn)}
}

func (_c *MockInitializer_RegisterAfterJoinGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error)) *MockInitializer_RegisterAfterJoinGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterJoinGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterJoinGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterJoinGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) error) error) *MockInitializer_RegisterAfterJoinGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterJoinTournament provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterJoinTournament(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterJoinTournament is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinTournamentRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterJoinTournament(fn interface{}) *MockInitializer_RegisterAfterJoinTournament_Call {
	return &MockInitializer_RegisterAfterJoinTournament_Call{Call: _e.mock.On("RegisterAfterJoinTournament", fn)}
}

func (_c *MockInitializer_RegisterAfterJoinTournament_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error)) *MockInitializer_RegisterAfterJoinTournament_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterJoinTournament_Call) Return(_a0 error) *MockInitializer_RegisterAfterJoinTournament_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterJoinTournament_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) error) error) *MockInitializer_RegisterAfterJoinTournament_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterKickGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterKickGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterKickGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.KickGroupUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterKickGroupUsers(fn interface{}) *MockInitializer_RegisterAfterKickGroupUsers_Call {
	return &MockInitializer_RegisterAfterKickGroupUsers_Call{Call: _e.mock.On("RegisterAfterKickGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterKickGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error)) *MockInitializer_RegisterAfterKickGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterKickGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterKickGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterKickGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) error) error) *MockInitializer_RegisterAfterKickGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLeaveGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLeaveGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLeaveGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaveGroupRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterLeaveGroup(fn interface{}) *MockInitializer_RegisterAfterLeaveGroup_Call {
	return &MockInitializer_RegisterAfterLeaveGroup_Call{Call: _e.mock.On("RegisterAfterLeaveGroup", fn)}
}

func (_c *MockInitializer_RegisterAfterLeaveGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error)) *MockInitializer_RegisterAfterLeaveGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLeaveGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterLeaveGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLeaveGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) error) error) *MockInitializer_RegisterAfterLeaveGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkApple(fn interface{}) *MockInitializer_RegisterAfterLinkApple_Call {
	return &MockInitializer_RegisterAfterLinkApple_Call{Call: _e.mock.On("RegisterAfterLinkApple", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error)) *MockInitializer_RegisterAfterLinkApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error) *MockInitializer_RegisterAfterLinkApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkCustom provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkCustom is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkCustom(fn interface{}) *MockInitializer_RegisterAfterLinkCustom_Call {
	return &MockInitializer_RegisterAfterLinkCustom_Call{Call: _e.mock.On("RegisterAfterLinkCustom", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error)) *MockInitializer_RegisterAfterLinkCustom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkCustom_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error) *MockInitializer_RegisterAfterLinkCustom_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkDevice provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkDevice is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkDevice(fn interface{}) *MockInitializer_RegisterAfterLinkDevice_Call {
	return &MockInitializer_RegisterAfterLinkDevice_Call{Call: _e.mock.On("RegisterAfterLinkDevice", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error)) *MockInitializer_RegisterAfterLinkDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error) *MockInitializer_RegisterAfterLinkDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkEmail provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkEmail is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkEmail(fn interface{}) *MockInitializer_RegisterAfterLinkEmail_Call {
	return &MockInitializer_RegisterAfterLinkEmail_Call{Call: _e.mock.On("RegisterAfterLinkEmail", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error)) *MockInitializer_RegisterAfterLinkEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkEmail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error) *MockInitializer_RegisterAfterLinkEmail_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkFacebook provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkFacebook is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkFacebookRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkFacebook(fn interface{}) *MockInitializer_RegisterAfterLinkFacebook_Call {
	return &MockInitializer_RegisterAfterLinkFacebook_Call{Call: _e.mock.On("RegisterAfterLinkFacebook", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error)) *MockInitializer_RegisterAfterLinkFacebook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkFacebook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) error) error) *MockInitializer_RegisterAfterLinkFacebook_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkFacebookInstantGame provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkFacebookInstantGame is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call {
	return &MockInitializer_RegisterAfterLinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterAfterLinkFacebookInstantGame", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error)) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error) *MockInitializer_RegisterAfterLinkFacebookInstantGame_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkGameCenter provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkGameCenter is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkGameCenter(fn interface{}) *MockInitializer_RegisterAfterLinkGameCenter_Call {
	return &MockInitializer_RegisterAfterLinkGameCenter_Call{Call: _e.mock.On("RegisterAfterLinkGameCenter", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error)) *MockInitializer_RegisterAfterLinkGameCenter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkGameCenter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error) *MockInitializer_RegisterAfterLinkGameCenter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkGoogle(fn interface{}) *MockInitializer_RegisterAfterLinkGoogle_Call {
	return &MockInitializer_RegisterAfterLinkGoogle_Call{Call: _e.mock.On("RegisterAfterLinkGoogle", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error)) *MockInitializer_RegisterAfterLinkGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error) *MockInitializer_RegisterAfterLinkGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterLinkSteam provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterLinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterLinkSteam is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkSteamRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterLinkSteam(fn interface{}) *MockInitializer_RegisterAfterLinkSteam_Call {
	return &MockInitializer_RegisterAfterLinkSteam_Call{Call: _e.mock.On("RegisterAfterLinkSteam", fn)}
}

func (_c *MockInitializer_RegisterAfterLinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error)) *MockInitializer_RegisterAfterLinkSteam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterAfterLinkSteam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterLinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) error) error) *MockInitializer_RegisterAfterLinkSteam_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListChannelMessages provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListChannelMessages(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListChannelMessages is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ChannelMessageList , *api.ListChannelMessagesRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListChannelMessages(fn interface{}) *MockInitializer_RegisterAfterListChannelMessages_Call {
	return &MockInitializer_RegisterAfterListChannelMessages_Call{Call: _e.mock.On("RegisterAfterListChannelMessages", fn)}
}

func (_c *MockInitializer_RegisterAfterListChannelMessages_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error)) *MockInitializer_RegisterAfterListChannelMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListChannelMessages_Call) Return(_a0 error) *MockInitializer_RegisterAfterListChannelMessages_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListChannelMessages_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ChannelMessageList, *api.ListChannelMessagesRequest) error) error) *MockInitializer_RegisterAfterListChannelMessages_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.FriendList) error
func (_e *MockInitializer_Expecter) RegisterAfterListFriends(fn interface{}) *MockInitializer_RegisterAfterListFriends_Call {
	return &MockInitializer_RegisterAfterListFriends_Call{Call: _e.mock.On("RegisterAfterListFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterListFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error)) *MockInitializer_RegisterAfterListFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterListFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendList) error) error) *MockInitializer_RegisterAfterListFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListFriendsOfFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListFriendsOfFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListFriendsOfFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.FriendsOfFriendsList) error
func (_e *MockInitializer_Expecter) RegisterAfterListFriendsOfFriends(fn interface{}) *MockInitializer_RegisterAfterListFriendsOfFriends_Call {
	return &MockInitializer_RegisterAfterListFriendsOfFriends_Call{Call: _e.mock.On("RegisterAfterListFriendsOfFriends", fn)}
}

func (_c *MockInitializer_RegisterAfterListFriendsOfFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error)) *MockInitializer_RegisterAfterListFriendsOfFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListFriendsOfFriends_Call) Return(_a0 error) *MockInitializer_RegisterAfterListFriendsOfFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListFriendsOfFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.FriendsOfFriendsList) error) error) *MockInitializer_RegisterAfterListFriendsOfFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GroupUserList , *api.ListGroupUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListGroupUsers(fn interface{}) *MockInitializer_RegisterAfterListGroupUsers_Call {
	return &MockInitializer_RegisterAfterListGroupUsers_Call{Call: _e.mock.On("RegisterAfterListGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterListGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error)) *MockInitializer_RegisterAfterListGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterListGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupUserList, *api.ListGroupUsersRequest) error) error) *MockInitializer_RegisterAfterListGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListGroups provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListGroups is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GroupList , *api.ListGroupsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListGroups(fn interface{}) *MockInitializer_RegisterAfterListGroups_Call {
	return &MockInitializer_RegisterAfterListGroups_Call{Call: _e.mock.On("RegisterAfterListGroups", fn)}
}

func (_c *MockInitializer_RegisterAfterListGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error)) *MockInitializer_RegisterAfterListGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListGroups_Call) Return(_a0 error) *MockInitializer_RegisterAfterListGroups_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GroupList, *api.ListGroupsRequest) error) error) *MockInitializer_RegisterAfterListGroups_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListLeaderboardRecords provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListLeaderboardRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListLeaderboardRecords is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecordList , *api.ListLeaderboardRecordsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListLeaderboardRecords(fn interface{}) *MockInitializer_RegisterAfterListLeaderboardRecords_Call {
	return &MockInitializer_RegisterAfterListLeaderboardRecords_Call{Call: _e.mock.On("RegisterAfterListLeaderboardRecords", fn)}
}

func (_c *MockInitializer_RegisterAfterListLeaderboardRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error)) *MockInitializer_RegisterAfterListLeaderboardRecords_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListLeaderboardRecords_Call) Return(_a0 error) *MockInitializer_RegisterAfterListLeaderboardRecords_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListLeaderboardRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsRequest) error) error) *MockInitializer_RegisterAfterListLeaderboardRecords_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListLeaderboardRecordsAroundOwner provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListLeaderboardRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListLeaderboardRecordsAroundOwner is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecordList , *api.ListLeaderboardRecordsAroundOwnerRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListLeaderboardRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call {
	return &MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call{Call: _e.mock.On("RegisterAfterListLeaderboardRecordsAroundOwner", fn)}
}

func (_c *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error)) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecordList, *api.ListLeaderboardRecordsAroundOwnerRequest) error) error) *MockInitializer_RegisterAfterListLeaderboardRecordsAroundOwner_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListMatches provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListMatches(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListMatches is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.MatchList , *api.ListMatchesRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListMatches(fn interface{}) *MockInitializer_RegisterAfterListMatches_Call {
	return &MockInitializer_RegisterAfterListMatches_Call{Call: _e.mock.On("RegisterAfterListMatches", fn)}
}

func (_c *MockInitializer_RegisterAfterListMatches_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error)) *MockInitializer_RegisterAfterListMatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListMatches_Call) Return(_a0 error) *MockInitializer_RegisterAfterListMatches_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListMatches_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.MatchList, *api.ListMatchesRequest) error) error) *MockInitializer_RegisterAfterListMatches_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListNotifications provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListNotifications is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.NotificationList , *api.ListNotificationsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListNotifications(fn interface{}) *MockInitializer_RegisterAfterListNotifications_Call {
	return &MockInitializer_RegisterAfterListNotifications_Call{Call: _e.mock.On("RegisterAfterListNotifications", fn)}
}

func (_c *MockInitializer_RegisterAfterListNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error)) *MockInitializer_RegisterAfterListNotifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListNotifications_Call) Return(_a0 error) *MockInitializer_RegisterAfterListNotifications_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.NotificationList, *api.ListNotificationsRequest) error) error) *MockInitializer_RegisterAfterListNotifications_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.StorageObjectList , *api.ListStorageObjectsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListStorageObjects(fn interface{}) *MockInitializer_RegisterAfterListStorageObjects_Call {
	return &MockInitializer_RegisterAfterListStorageObjects_Call{Call: _e.mock.On("RegisterAfterListStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterAfterListStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error)) *MockInitializer_RegisterAfterListStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterListStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectList, *api.ListStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterListStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListSubscriptions provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListSubscriptions(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListSubscriptions is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SubscriptionList , *api.ListSubscriptionsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListSubscriptions(fn interface{}) *MockInitializer_RegisterAfterListSubscriptions_Call {
	return &MockInitializer_RegisterAfterListSubscriptions_Call{Call: _e.mock.On("RegisterAfterListSubscriptions", fn)}
}

func (_c *MockInitializer_RegisterAfterListSubscriptions_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error)) *MockInitializer_RegisterAfterListSubscriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListSubscriptions_Call) Return(_a0 error) *MockInitializer_RegisterAfterListSubscriptions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListSubscriptions_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SubscriptionList, *api.ListSubscriptionsRequest) error) error) *MockInitializer_RegisterAfterListSubscriptions_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListTournamentRecords provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListTournamentRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListTournamentRecords is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.TournamentRecordList , *api.ListTournamentRecordsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListTournamentRecords(fn interface{}) *MockInitializer_RegisterAfterListTournamentRecords_Call {
	return &MockInitializer_RegisterAfterListTournamentRecords_Call{Call: _e.mock.On("RegisterAfterListTournamentRecords", fn)}
}

func (_c *MockInitializer_RegisterAfterListTournamentRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error)) *MockInitializer_RegisterAfterListTournamentRecords_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListTournamentRecords_Call) Return(_a0 error) *MockInitializer_RegisterAfterListTournamentRecords_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListTournamentRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsRequest) error) error) *MockInitializer_RegisterAfterListTournamentRecords_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListTournamentRecordsAroundOwner provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListTournamentRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListTournamentRecordsAroundOwner is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.TournamentRecordList , *api.ListTournamentRecordsAroundOwnerRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListTournamentRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call {
	return &MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call{Call: _e.mock.On("RegisterAfterListTournamentRecordsAroundOwner", fn)}
}

func (_c *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error)) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentRecordList, *api.ListTournamentRecordsAroundOwnerRequest) error) error) *MockInitializer_RegisterAfterListTournamentRecordsAroundOwner_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListTournaments provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListTournaments(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListTournaments is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.TournamentList , *api.ListTournamentsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListTournaments(fn interface{}) *MockInitializer_RegisterAfterListTournaments_Call {
	return &MockInitializer_RegisterAfterListTournaments_Call{Call: _e.mock.On("RegisterAfterListTournaments", fn)}
}

func (_c *MockInitializer_RegisterAfterListTournaments_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error)) *MockInitializer_RegisterAfterListTournaments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListTournaments_Call) Return(_a0 error) *MockInitializer_RegisterAfterListTournaments_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListTournaments_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.TournamentList, *api.ListTournamentsRequest) error) error) *MockInitializer_RegisterAfterListTournaments_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterListUserGroups provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterListUserGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterListUserGroups is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UserGroupList , *api.ListUserGroupsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterListUserGroups(fn interface{}) *MockInitializer_RegisterAfterListUserGroups_Call {
	return &MockInitializer_RegisterAfterListUserGroups_Call{Call: _e.mock.On("RegisterAfterListUserGroups", fn)}
}

func (_c *MockInitializer_RegisterAfterListUserGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error)) *MockInitializer_RegisterAfterListUserGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterListUserGroups_Call) Return(_a0 error) *MockInitializer_RegisterAfterListUserGroups_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterListUserGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UserGroupList, *api.ListUserGroupsRequest) error) error) *MockInitializer_RegisterAfterListUserGroups_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterPromoteGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterPromoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterPromoteGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.PromoteGroupUsersRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterPromoteGroupUsers(fn interface{}) *MockInitializer_RegisterAfterPromoteGroupUsers_Call {
	return &MockInitializer_RegisterAfterPromoteGroupUsers_Call{Call: _e.mock.On("RegisterAfterPromoteGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterAfterPromoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error)) *MockInitializer_RegisterAfterPromoteGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterPromoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterAfterPromoteGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterPromoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) error) error) *MockInitializer_RegisterAfterPromoteGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterReadStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterReadStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterReadStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.StorageObjects , *api.ReadStorageObjectsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterReadStorageObjects(fn interface{}) *MockInitializer_RegisterAfterReadStorageObjects_Call {
	return &MockInitializer_RegisterAfterReadStorageObjects_Call{Call: _e.mock.On("RegisterAfterReadStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterAfterReadStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error)) *MockInitializer_RegisterAfterReadStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterReadStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterReadStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterReadStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjects, *api.ReadStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterReadStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterRt provides a mock function with given fields: id, fn
func (_m *MockInitializer) RegisterAfterRt(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error) error {
	ret := _m.Called(id, fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error) error); ok {
		r0 = rf(id, fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterRt is a helper method to define mock.On call
//   - id string
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *rtapi.Envelope , *rtapi.Envelope) error
func (_e *MockInitializer_Expecter) RegisterAfterRt(id interface{}, fn interface{}) *MockInitializer_RegisterAfterRt_Call {
	return &MockInitializer_RegisterAfterRt_Call{Call: _e.mock.On("RegisterAfterRt", id, fn)}
}

func (_c *MockInitializer_RegisterAfterRt_Call) Run(run func(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error)) *MockInitializer_RegisterAfterRt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterRt_Call) Return(_a0 error) *MockInitializer_RegisterAfterRt_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterRt_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope, *rtapi.Envelope) error) error) *MockInitializer_RegisterAfterRt_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterSessionLogout provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterSessionLogout(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterSessionLogout is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SessionLogoutRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterSessionLogout(fn interface{}) *MockInitializer_RegisterAfterSessionLogout_Call {
	return &MockInitializer_RegisterAfterSessionLogout_Call{Call: _e.mock.On("RegisterAfterSessionLogout", fn)}
}

func (_c *MockInitializer_RegisterAfterSessionLogout_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error)) *MockInitializer_RegisterAfterSessionLogout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterSessionLogout_Call) Return(_a0 error) *MockInitializer_RegisterAfterSessionLogout_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterSessionLogout_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) error) error) *MockInitializer_RegisterAfterSessionLogout_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterSessionRefresh provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterSessionRefresh(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterSessionRefresh is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Session , *api.SessionRefreshRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterSessionRefresh(fn interface{}) *MockInitializer_RegisterAfterSessionRefresh_Call {
	return &MockInitializer_RegisterAfterSessionRefresh_Call{Call: _e.mock.On("RegisterAfterSessionRefresh", fn)}
}

func (_c *MockInitializer_RegisterAfterSessionRefresh_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error)) *MockInitializer_RegisterAfterSessionRefresh_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterSessionRefresh_Call) Return(_a0 error) *MockInitializer_RegisterAfterSessionRefresh_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterSessionRefresh_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Session, *api.SessionRefreshRequest) error) error) *MockInitializer_RegisterAfterSessionRefresh_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkApple(fn interface{}) *MockInitializer_RegisterAfterUnlinkApple_Call {
	return &MockInitializer_RegisterAfterUnlinkApple_Call{Call: _e.mock.On("RegisterAfterUnlinkApple", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error)) *MockInitializer_RegisterAfterUnlinkApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) error) error) *MockInitializer_RegisterAfterUnlinkApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkCustom provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkCustom is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkCustom(fn interface{}) *MockInitializer_RegisterAfterUnlinkCustom_Call {
	return &MockInitializer_RegisterAfterUnlinkCustom_Call{Call: _e.mock.On("RegisterAfterUnlinkCustom", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error)) *MockInitializer_RegisterAfterUnlinkCustom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkCustom_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) error) error) *MockInitializer_RegisterAfterUnlinkCustom_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkDevice provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkDevice is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkDevice(fn interface{}) *MockInitializer_RegisterAfterUnlinkDevice_Call {
	return &MockInitializer_RegisterAfterUnlinkDevice_Call{Call: _e.mock.On("RegisterAfterUnlinkDevice", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error)) *MockInitializer_RegisterAfterUnlinkDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) error) error) *MockInitializer_RegisterAfterUnlinkDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkEmail provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkEmail is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkEmail(fn interface{}) *MockInitializer_RegisterAfterUnlinkEmail_Call {
	return &MockInitializer_RegisterAfterUnlinkEmail_Call{Call: _e.mock.On("RegisterAfterUnlinkEmail", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error)) *MockInitializer_RegisterAfterUnlinkEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkEmail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) error) error) *MockInitializer_RegisterAfterUnlinkEmail_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkFacebook provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkFacebook is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebook) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkFacebook(fn interface{}) *MockInitializer_RegisterAfterUnlinkFacebook_Call {
	return &MockInitializer_RegisterAfterUnlinkFacebook_Call{Call: _e.mock.On("RegisterAfterUnlinkFacebook", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error)) *MockInitializer_RegisterAfterUnlinkFacebook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkFacebook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) error) error) *MockInitializer_RegisterAfterUnlinkFacebook_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkFacebookInstantGame provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkFacebookInstantGame is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call {
	return &MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterAfterUnlinkFacebookInstantGame", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error)) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) error) error) *MockInitializer_RegisterAfterUnlinkFacebookInstantGame_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkGameCenter provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkGameCenter is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkGameCenter(fn interface{}) *MockInitializer_RegisterAfterUnlinkGameCenter_Call {
	return &MockInitializer_RegisterAfterUnlinkGameCenter_Call{Call: _e.mock.On("RegisterAfterUnlinkGameCenter", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error)) *MockInitializer_RegisterAfterUnlinkGameCenter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkGameCenter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) error) error) *MockInitializer_RegisterAfterUnlinkGameCenter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkGoogle(fn interface{}) *MockInitializer_RegisterAfterUnlinkGoogle_Call {
	return &MockInitializer_RegisterAfterUnlinkGoogle_Call{Call: _e.mock.On("RegisterAfterUnlinkGoogle", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error)) *MockInitializer_RegisterAfterUnlinkGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) error) error) *MockInitializer_RegisterAfterUnlinkGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUnlinkSteam provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUnlinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUnlinkSteam is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountSteam) error
func (_e *MockInitializer_Expecter) RegisterAfterUnlinkSteam(fn interface{}) *MockInitializer_RegisterAfterUnlinkSteam_Call {
	return &MockInitializer_RegisterAfterUnlinkSteam_Call{Call: _e.mock.On("RegisterAfterUnlinkSteam", fn)}
}

func (_c *MockInitializer_RegisterAfterUnlinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error)) *MockInitializer_RegisterAfterUnlinkSteam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterAfterUnlinkSteam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUnlinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) error) error) *MockInitializer_RegisterAfterUnlinkSteam_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUpdateAccount provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUpdateAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUpdateAccount is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateAccountRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterUpdateAccount(fn interface{}) *MockInitializer_RegisterAfterUpdateAccount_Call {
	return &MockInitializer_RegisterAfterUpdateAccount_Call{Call: _e.mock.On("RegisterAfterUpdateAccount", fn)}
}

func (_c *MockInitializer_RegisterAfterUpdateAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error)) *MockInitializer_RegisterAfterUpdateAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUpdateAccount_Call) Return(_a0 error) *MockInitializer_RegisterAfterUpdateAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUpdateAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) error) error) *MockInitializer_RegisterAfterUpdateAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterUpdateGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterUpdateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterUpdateGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateGroupRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterUpdateGroup(fn interface{}) *MockInitializer_RegisterAfterUpdateGroup_Call {
	return &MockInitializer_RegisterAfterUpdateGroup_Call{Call: _e.mock.On("RegisterAfterUpdateGroup", fn)}
}

func (_c *MockInitializer_RegisterAfterUpdateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error)) *MockInitializer_RegisterAfterUpdateGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterUpdateGroup_Call) Return(_a0 error) *MockInitializer_RegisterAfterUpdateGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterUpdateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) error) error) *MockInitializer_RegisterAfterUpdateGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterValidatePurchaseApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterValidatePurchaseApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterValidatePurchaseApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseAppleRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseApple(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseApple_Call {
	return &MockInitializer_RegisterAfterValidatePurchaseApple_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseApple", fn)}
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseAppleRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterValidatePurchaseFacebookInstant provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterValidatePurchaseFacebookInstant(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterValidatePurchaseFacebookInstant is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseFacebookInstantRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseFacebookInstant(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call {
	return &MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseFacebookInstant", fn)}
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseFacebookInstantRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseFacebookInstant_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterValidatePurchaseGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterValidatePurchaseGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterValidatePurchaseGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseGoogleRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseGoogle(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call {
	return &MockInitializer_RegisterAfterValidatePurchaseGoogle_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseGoogle", fn)}
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseGoogleRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterValidatePurchaseHuawei provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterValidatePurchaseHuawei(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterValidatePurchaseHuawei is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseResponse , *api.ValidatePurchaseHuaweiRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterValidatePurchaseHuawei(fn interface{}) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call {
	return &MockInitializer_RegisterAfterValidatePurchaseHuawei_Call{Call: _e.mock.On("RegisterAfterValidatePurchaseHuawei", fn)}
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error)) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseResponse, *api.ValidatePurchaseHuaweiRequest) error) error) *MockInitializer_RegisterAfterValidatePurchaseHuawei_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterValidateSubscriptionApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterValidateSubscriptionApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterValidateSubscriptionApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionResponse , *api.ValidateSubscriptionAppleRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterValidateSubscriptionApple(fn interface{}) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call {
	return &MockInitializer_RegisterAfterValidateSubscriptionApple_Call{Call: _e.mock.On("RegisterAfterValidateSubscriptionApple", fn)}
}

func (_c *MockInitializer_RegisterAfterValidateSubscriptionApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error)) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterValidateSubscriptionApple_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterValidateSubscriptionApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionAppleRequest) error) error) *MockInitializer_RegisterAfterValidateSubscriptionApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterValidateSubscriptionGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterValidateSubscriptionGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterValidateSubscriptionGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionResponse , *api.ValidateSubscriptionGoogleRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterValidateSubscriptionGoogle(fn interface{}) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call {
	return &MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call{Call: _e.mock.On("RegisterAfterValidateSubscriptionGoogle", fn)}
}

func (_c *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error)) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call) Return(_a0 error) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionResponse, *api.ValidateSubscriptionGoogleRequest) error) error) *MockInitializer_RegisterAfterValidateSubscriptionGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterWriteLeaderboardRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterWriteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterWriteLeaderboardRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecord , *api.WriteLeaderboardRecordRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterWriteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call {
	return &MockInitializer_RegisterAfterWriteLeaderboardRecord_Call{Call: _e.mock.On("RegisterAfterWriteLeaderboardRecord", fn)}
}

func (_c *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error)) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteLeaderboardRecordRequest) error) error) *MockInitializer_RegisterAfterWriteLeaderboardRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterWriteStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterWriteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterWriteStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.StorageObjectAcks , *api.WriteStorageObjectsRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterWriteStorageObjects(fn interface{}) *MockInitializer_RegisterAfterWriteStorageObjects_Call {
	return &MockInitializer_RegisterAfterWriteStorageObjects_Call{Call: _e.mock.On("RegisterAfterWriteStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterAfterWriteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error)) *MockInitializer_RegisterAfterWriteStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterWriteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterAfterWriteStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterWriteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.StorageObjectAcks, *api.WriteStorageObjectsRequest) error) error) *MockInitializer_RegisterAfterWriteStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterAfterWriteTournamentRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterAfterWriteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterAfterWriteTournamentRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaderboardRecord , *api.WriteTournamentRecordRequest) error
func (_e *MockInitializer_Expecter) RegisterAfterWriteTournamentRecord(fn interface{}) *MockInitializer_RegisterAfterWriteTournamentRecord_Call {
	return &MockInitializer_RegisterAfterWriteTournamentRecord_Call{Call: _e.mock.On("RegisterAfterWriteTournamentRecord", fn)}
}

func (_c *MockInitializer_RegisterAfterWriteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error)) *MockInitializer_RegisterAfterWriteTournamentRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterAfterWriteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterAfterWriteTournamentRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterAfterWriteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaderboardRecord, *api.WriteTournamentRecordRequest) error) error) *MockInitializer_RegisterAfterWriteTournamentRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAddFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAddFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAddFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddFriendsRequest)(*api.AddFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAddFriends(fn interface{}) *MockInitializer_RegisterBeforeAddFriends_Call {
	return &MockInitializer_RegisterBeforeAddFriends_Call{Call: _e.mock.On("RegisterBeforeAddFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeAddFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error))) *MockInitializer_RegisterBeforeAddFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAddFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAddFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAddFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddFriendsRequest) (*api.AddFriendsRequest, error)) error) *MockInitializer_RegisterBeforeAddFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAddGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAddGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAddGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AddGroupUsersRequest)(*api.AddGroupUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAddGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeAddGroupUsers_Call {
	return &MockInitializer_RegisterBeforeAddGroupUsers_Call{Call: _e.mock.On("RegisterBeforeAddGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforeAddGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error))) *MockInitializer_RegisterBeforeAddGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAddGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAddGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAddGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AddGroupUsersRequest) (*api.AddGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeAddGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateAppleRequest)(*api.AuthenticateAppleRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateApple(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateApple_Call {
	return &MockInitializer_RegisterBeforeAuthenticateApple_Call{Call: _e.mock.On("RegisterBeforeAuthenticateApple", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error))) *MockInitializer_RegisterBeforeAuthenticateApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateAppleRequest) (*api.AuthenticateAppleRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateCustom provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateCustom is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateCustomRequest)(*api.AuthenticateCustomRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateCustom(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateCustom_Call {
	return &MockInitializer_RegisterBeforeAuthenticateCustom_Call{Call: _e.mock.On("RegisterBeforeAuthenticateCustom", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error))) *MockInitializer_RegisterBeforeAuthenticateCustom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateCustom_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateCustom_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateCustomRequest) (*api.AuthenticateCustomRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateCustom_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateDevice provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateDevice is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateDeviceRequest)(*api.AuthenticateDeviceRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateDevice(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateDevice_Call {
	return &MockInitializer_RegisterBeforeAuthenticateDevice_Call{Call: _e.mock.On("RegisterBeforeAuthenticateDevice", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error))) *MockInitializer_RegisterBeforeAuthenticateDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateDevice_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateDeviceRequest) (*api.AuthenticateDeviceRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateEmail provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateEmail is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateEmailRequest)(*api.AuthenticateEmailRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateEmail(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateEmail_Call {
	return &MockInitializer_RegisterBeforeAuthenticateEmail_Call{Call: _e.mock.On("RegisterBeforeAuthenticateEmail", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error))) *MockInitializer_RegisterBeforeAuthenticateEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateEmail_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateEmail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateEmailRequest) (*api.AuthenticateEmailRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateEmail_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateFacebook provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateFacebook is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateFacebookRequest)(*api.AuthenticateFacebookRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateFacebook(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call {
	return &MockInitializer_RegisterBeforeAuthenticateFacebook_Call{Call: _e.mock.On("RegisterBeforeAuthenticateFacebook", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error))) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateFacebook_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookRequest) (*api.AuthenticateFacebookRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateFacebook_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateFacebookInstantGame provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateFacebookInstantGame is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateFacebookInstantGameRequest)(*api.AuthenticateFacebookInstantGameRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateFacebookInstantGame(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call {
	return &MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call{Call: _e.mock.On("RegisterBeforeAuthenticateFacebookInstantGame", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error))) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateFacebookInstantGameRequest) (*api.AuthenticateFacebookInstantGameRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateFacebookInstantGame_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateGameCenter provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateGameCenter is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateGameCenterRequest)(*api.AuthenticateGameCenterRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateGameCenter(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call {
	return &MockInitializer_RegisterBeforeAuthenticateGameCenter_Call{Call: _e.mock.On("RegisterBeforeAuthenticateGameCenter", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error))) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGameCenterRequest) (*api.AuthenticateGameCenterRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateGameCenter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateGoogleRequest)(*api.AuthenticateGoogleRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateGoogle(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call {
	return &MockInitializer_RegisterBeforeAuthenticateGoogle_Call{Call: _e.mock.On("RegisterBeforeAuthenticateGoogle", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error))) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateGoogleRequest) (*api.AuthenticateGoogleRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeAuthenticateSteam provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeAuthenticateSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeAuthenticateSteam is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AuthenticateSteamRequest)(*api.AuthenticateSteamRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeAuthenticateSteam(fn interface{}) *MockInitializer_RegisterBeforeAuthenticateSteam_Call {
	return &MockInitializer_RegisterBeforeAuthenticateSteam_Call{Call: _e.mock.On("RegisterBeforeAuthenticateSteam", fn)}
}

func (_c *MockInitializer_RegisterBeforeAuthenticateSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error))) *MockInitializer_RegisterBeforeAuthenticateSteam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateSteam_Call) Return(_a0 error) *MockInitializer_RegisterBeforeAuthenticateSteam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeAuthenticateSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AuthenticateSteamRequest) (*api.AuthenticateSteamRequest, error)) error) *MockInitializer_RegisterBeforeAuthenticateSteam_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeBanGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeBanGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeBanGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BanGroupUsersRequest)(*api.BanGroupUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeBanGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeBanGroupUsers_Call {
	return &MockInitializer_RegisterBeforeBanGroupUsers_Call{Call: _e.mock.On("RegisterBeforeBanGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforeBanGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error))) *MockInitializer_RegisterBeforeBanGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeBanGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeBanGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeBanGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BanGroupUsersRequest) (*api.BanGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeBanGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeBlockFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeBlockFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeBlockFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.BlockFriendsRequest)(*api.BlockFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeBlockFriends(fn interface{}) *MockInitializer_RegisterBeforeBlockFriends_Call {
	return &MockInitializer_RegisterBeforeBlockFriends_Call{Call: _e.mock.On("RegisterBeforeBlockFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeBlockFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error))) *MockInitializer_RegisterBeforeBlockFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeBlockFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeBlockFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeBlockFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.BlockFriendsRequest) (*api.BlockFriendsRequest, error)) error) *MockInitializer_RegisterBeforeBlockFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeCreateGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeCreateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeCreateGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.CreateGroupRequest)(*api.CreateGroupRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeCreateGroup(fn interface{}) *MockInitializer_RegisterBeforeCreateGroup_Call {
	return &MockInitializer_RegisterBeforeCreateGroup_Call{Call: _e.mock.On("RegisterBeforeCreateGroup", fn)}
}

func (_c *MockInitializer_RegisterBeforeCreateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error))) *MockInitializer_RegisterBeforeCreateGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeCreateGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeCreateGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeCreateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.CreateGroupRequest) (*api.CreateGroupRequest, error)) error) *MockInitializer_RegisterBeforeCreateGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteAccount provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteAccount is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteAccount(fn interface{}) *MockInitializer_RegisterBeforeDeleteAccount_Call {
	return &MockInitializer_RegisterBeforeDeleteAccount_Call{Call: _e.mock.On("RegisterBeforeDeleteAccount", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterBeforeDeleteAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteAccount_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterBeforeDeleteAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteFriendsRequest)(*api.DeleteFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteFriends(fn interface{}) *MockInitializer_RegisterBeforeDeleteFriends_Call {
	return &MockInitializer_RegisterBeforeDeleteFriends_Call{Call: _e.mock.On("RegisterBeforeDeleteFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error))) *MockInitializer_RegisterBeforeDeleteFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteFriendsRequest) (*api.DeleteFriendsRequest, error)) error) *MockInitializer_RegisterBeforeDeleteFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteGroupRequest)(*api.DeleteGroupRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteGroup(fn interface{}) *MockInitializer_RegisterBeforeDeleteGroup_Call {
	return &MockInitializer_RegisterBeforeDeleteGroup_Call{Call: _e.mock.On("RegisterBeforeDeleteGroup", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error))) *MockInitializer_RegisterBeforeDeleteGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteGroupRequest) (*api.DeleteGroupRequest, error)) error) *MockInitializer_RegisterBeforeDeleteGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteLeaderboardRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteLeaderboardRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteLeaderboardRecordRequest)(*api.DeleteLeaderboardRecordRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call {
	return &MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call{Call: _e.mock.On("RegisterBeforeDeleteLeaderboardRecord", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error))) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteLeaderboardRecordRequest) (*api.DeleteLeaderboardRecordRequest, error)) error) *MockInitializer_RegisterBeforeDeleteLeaderboardRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteNotifications provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteNotifications is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteNotificationsRequest)(*api.DeleteNotificationsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteNotifications(fn interface{}) *MockInitializer_RegisterBeforeDeleteNotifications_Call {
	return &MockInitializer_RegisterBeforeDeleteNotifications_Call{Call: _e.mock.On("RegisterBeforeDeleteNotifications", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error))) *MockInitializer_RegisterBeforeDeleteNotifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteNotifications_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteNotifications_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteNotificationsRequest) (*api.DeleteNotificationsRequest, error)) error) *MockInitializer_RegisterBeforeDeleteNotifications_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteStorageObjectsRequest)(*api.DeleteStorageObjectsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call {
	return &MockInitializer_RegisterBeforeDeleteStorageObjects_Call{Call: _e.mock.On("RegisterBeforeDeleteStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteStorageObjectsRequest) (*api.DeleteStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeDeleteStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDeleteTournamentRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDeleteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDeleteTournamentRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DeleteTournamentRecordRequest)(*api.DeleteTournamentRecordRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDeleteTournamentRecord(fn interface{}) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call {
	return &MockInitializer_RegisterBeforeDeleteTournamentRecord_Call{Call: _e.mock.On("RegisterBeforeDeleteTournamentRecord", fn)}
}

func (_c *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error))) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DeleteTournamentRecordRequest) (*api.DeleteTournamentRecordRequest, error)) error) *MockInitializer_RegisterBeforeDeleteTournamentRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeDemoteGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeDemoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeDemoteGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.DemoteGroupUsersRequest)(*api.DemoteGroupUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeDemoteGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call {
	return &MockInitializer_RegisterBeforeDemoteGroupUsers_Call{Call: _e.mock.On("RegisterBeforeDemoteGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforeDemoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error))) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeDemoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeDemoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.DemoteGroupUsersRequest) (*api.DemoteGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeDemoteGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeGetAccount provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeGetAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeGetAccount is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error
func (_e *MockInitializer_Expecter) RegisterBeforeGetAccount(fn interface{}) *MockInitializer_RegisterBeforeGetAccount_Call {
	return &MockInitializer_RegisterBeforeGetAccount_Call{Call: _e.mock.On("RegisterBeforeGetAccount", fn)}
}

func (_c *MockInitializer_RegisterBeforeGetAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterBeforeGetAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetAccount_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterBeforeGetAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeGetMatchmakerStats provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeGetMatchmakerStats(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeGetMatchmakerStats is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule) error
func (_e *MockInitializer_Expecter) RegisterBeforeGetMatchmakerStats(fn interface{}) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call {
	return &MockInitializer_RegisterBeforeGetMatchmakerStats_Call{Call: _e.mock.On("RegisterBeforeGetMatchmakerStats", fn)}
}

func (_c *MockInitializer_RegisterBeforeGetMatchmakerStats_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error)) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetMatchmakerStats_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetMatchmakerStats_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) error) error) *MockInitializer_RegisterBeforeGetMatchmakerStats_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeGetSubscription provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeGetSubscription(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeGetSubscription is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GetSubscriptionRequest)(*api.GetSubscriptionRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeGetSubscription(fn interface{}) *MockInitializer_RegisterBeforeGetSubscription_Call {
	return &MockInitializer_RegisterBeforeGetSubscription_Call{Call: _e.mock.On("RegisterBeforeGetSubscription", fn)}
}

func (_c *MockInitializer_RegisterBeforeGetSubscription_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error))) *MockInitializer_RegisterBeforeGetSubscription_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetSubscription_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetSubscription_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetSubscription_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetSubscriptionRequest) (*api.GetSubscriptionRequest, error)) error) *MockInitializer_RegisterBeforeGetSubscription_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeGetUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeGetUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeGetUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.GetUsersRequest)(*api.GetUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeGetUsers(fn interface{}) *MockInitializer_RegisterBeforeGetUsers_Call {
	return &MockInitializer_RegisterBeforeGetUsers_Call{Call: _e.mock.On("RegisterBeforeGetUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforeGetUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error))) *MockInitializer_RegisterBeforeGetUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeGetUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeGetUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.GetUsersRequest) (*api.GetUsersRequest, error)) error) *MockInitializer_RegisterBeforeGetUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeImportFacebookFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeImportFacebookFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeImportFacebookFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportFacebookFriendsRequest)(*api.ImportFacebookFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeImportFacebookFriends(fn interface{}) *MockInitializer_RegisterBeforeImportFacebookFriends_Call {
	return &MockInitializer_RegisterBeforeImportFacebookFriends_Call{Call: _e.mock.On("RegisterBeforeImportFacebookFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeImportFacebookFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error))) *MockInitializer_RegisterBeforeImportFacebookFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeImportFacebookFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeImportFacebookFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeImportFacebookFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportFacebookFriendsRequest) (*api.ImportFacebookFriendsRequest, error)) error) *MockInitializer_RegisterBeforeImportFacebookFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeImportSteamFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeImportSteamFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeImportSteamFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ImportSteamFriendsRequest)(*api.ImportSteamFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeImportSteamFriends(fn interface{}) *MockInitializer_RegisterBeforeImportSteamFriends_Call {
	return &MockInitializer_RegisterBeforeImportSteamFriends_Call{Call: _e.mock.On("RegisterBeforeImportSteamFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeImportSteamFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error))) *MockInitializer_RegisterBeforeImportSteamFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeImportSteamFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeImportSteamFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeImportSteamFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ImportSteamFriendsRequest) (*api.ImportSteamFriendsRequest, error)) error) *MockInitializer_RegisterBeforeImportSteamFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeJoinGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeJoinGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeJoinGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinGroupRequest)(*api.JoinGroupRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeJoinGroup(fn interface{}) *MockInitializer_RegisterBeforeJoinGroup_Call {
	return &MockInitializer_RegisterBeforeJoinGroup_Call{Call: _e.mock.On("RegisterBeforeJoinGroup", fn)}
}

func (_c *MockInitializer_RegisterBeforeJoinGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error))) *MockInitializer_RegisterBeforeJoinGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeJoinGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeJoinGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeJoinGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinGroupRequest) (*api.JoinGroupRequest, error)) error) *MockInitializer_RegisterBeforeJoinGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeJoinTournament provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeJoinTournament(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeJoinTournament is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.JoinTournamentRequest)(*api.JoinTournamentRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeJoinTournament(fn interface{}) *MockInitializer_RegisterBeforeJoinTournament_Call {
	return &MockInitializer_RegisterBeforeJoinTournament_Call{Call: _e.mock.On("RegisterBeforeJoinTournament", fn)}
}

func (_c *MockInitializer_RegisterBeforeJoinTournament_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error))) *MockInitializer_RegisterBeforeJoinTournament_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeJoinTournament_Call) Return(_a0 error) *MockInitializer_RegisterBeforeJoinTournament_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeJoinTournament_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.JoinTournamentRequest) (*api.JoinTournamentRequest, error)) error) *MockInitializer_RegisterBeforeJoinTournament_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeKickGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeKickGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeKickGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.KickGroupUsersRequest)(*api.KickGroupUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeKickGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeKickGroupUsers_Call {
	return &MockInitializer_RegisterBeforeKickGroupUsers_Call{Call: _e.mock.On("RegisterBeforeKickGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforeKickGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error))) *MockInitializer_RegisterBeforeKickGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeKickGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeKickGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeKickGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.KickGroupUsersRequest) (*api.KickGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeKickGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLeaveGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLeaveGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLeaveGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LeaveGroupRequest)(*api.LeaveGroupRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLeaveGroup(fn interface{}) *MockInitializer_RegisterBeforeLeaveGroup_Call {
	return &MockInitializer_RegisterBeforeLeaveGroup_Call{Call: _e.mock.On("RegisterBeforeLeaveGroup", fn)}
}

func (_c *MockInitializer_RegisterBeforeLeaveGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error))) *MockInitializer_RegisterBeforeLeaveGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLeaveGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLeaveGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLeaveGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LeaveGroupRequest) (*api.LeaveGroupRequest, error)) error) *MockInitializer_RegisterBeforeLeaveGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple)(*api.AccountApple , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkApple(fn interface{}) *MockInitializer_RegisterBeforeLinkApple_Call {
	return &MockInitializer_RegisterBeforeLinkApple_Call{Call: _e.mock.On("RegisterBeforeLinkApple", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error))) *MockInitializer_RegisterBeforeLinkApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error) *MockInitializer_RegisterBeforeLinkApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkCustom provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkCustom is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom)(*api.AccountCustom , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkCustom(fn interface{}) *MockInitializer_RegisterBeforeLinkCustom_Call {
	return &MockInitializer_RegisterBeforeLinkCustom_Call{Call: _e.mock.On("RegisterBeforeLinkCustom", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error))) *MockInitializer_RegisterBeforeLinkCustom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkCustom_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error) *MockInitializer_RegisterBeforeLinkCustom_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkDevice provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkDevice is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice)(*api.AccountDevice , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkDevice(fn interface{}) *MockInitializer_RegisterBeforeLinkDevice_Call {
	return &MockInitializer_RegisterBeforeLinkDevice_Call{Call: _e.mock.On("RegisterBeforeLinkDevice", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error))) *MockInitializer_RegisterBeforeLinkDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error) *MockInitializer_RegisterBeforeLinkDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkEmail provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkEmail is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail)(*api.AccountEmail , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkEmail(fn interface{}) *MockInitializer_RegisterBeforeLinkEmail_Call {
	return &MockInitializer_RegisterBeforeLinkEmail_Call{Call: _e.mock.On("RegisterBeforeLinkEmail", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error))) *MockInitializer_RegisterBeforeLinkEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkEmail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error) *MockInitializer_RegisterBeforeLinkEmail_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkFacebook provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkFacebook is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkFacebookRequest)(*api.LinkFacebookRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkFacebook(fn interface{}) *MockInitializer_RegisterBeforeLinkFacebook_Call {
	return &MockInitializer_RegisterBeforeLinkFacebook_Call{Call: _e.mock.On("RegisterBeforeLinkFacebook", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error))) *MockInitializer_RegisterBeforeLinkFacebook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkFacebook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkFacebookRequest) (*api.LinkFacebookRequest, error)) error) *MockInitializer_RegisterBeforeLinkFacebook_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkFacebookInstantGame provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkFacebookInstantGame is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame)(*api.AccountFacebookInstantGame , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call {
	return &MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterBeforeLinkFacebookInstantGame", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error))) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error) *MockInitializer_RegisterBeforeLinkFacebookInstantGame_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkGameCenter provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkGameCenter is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter)(*api.AccountGameCenter , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkGameCenter(fn interface{}) *MockInitializer_RegisterBeforeLinkGameCenter_Call {
	return &MockInitializer_RegisterBeforeLinkGameCenter_Call{Call: _e.mock.On("RegisterBeforeLinkGameCenter", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error))) *MockInitializer_RegisterBeforeLinkGameCenter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkGameCenter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error) *MockInitializer_RegisterBeforeLinkGameCenter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle)(*api.AccountGoogle , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkGoogle(fn interface{}) *MockInitializer_RegisterBeforeLinkGoogle_Call {
	return &MockInitializer_RegisterBeforeLinkGoogle_Call{Call: _e.mock.On("RegisterBeforeLinkGoogle", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error))) *MockInitializer_RegisterBeforeLinkGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error) *MockInitializer_RegisterBeforeLinkGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeLinkSteam provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeLinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeLinkSteam is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.LinkSteamRequest)(*api.LinkSteamRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeLinkSteam(fn interface{}) *MockInitializer_RegisterBeforeLinkSteam_Call {
	return &MockInitializer_RegisterBeforeLinkSteam_Call{Call: _e.mock.On("RegisterBeforeLinkSteam", fn)}
}

func (_c *MockInitializer_RegisterBeforeLinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error))) *MockInitializer_RegisterBeforeLinkSteam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterBeforeLinkSteam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeLinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.LinkSteamRequest) (*api.LinkSteamRequest, error)) error) *MockInitializer_RegisterBeforeLinkSteam_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListChannelMessages provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListChannelMessages(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListChannelMessages is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListChannelMessagesRequest)(*api.ListChannelMessagesRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListChannelMessages(fn interface{}) *MockInitializer_RegisterBeforeListChannelMessages_Call {
	return &MockInitializer_RegisterBeforeListChannelMessages_Call{Call: _e.mock.On("RegisterBeforeListChannelMessages", fn)}
}

func (_c *MockInitializer_RegisterBeforeListChannelMessages_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error))) *MockInitializer_RegisterBeforeListChannelMessages_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListChannelMessages_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListChannelMessages_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListChannelMessages_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListChannelMessagesRequest) (*api.ListChannelMessagesRequest, error)) error) *MockInitializer_RegisterBeforeListChannelMessages_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListFriendsRequest)(*api.ListFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListFriends(fn interface{}) *MockInitializer_RegisterBeforeListFriends_Call {
	return &MockInitializer_RegisterBeforeListFriends_Call{Call: _e.mock.On("RegisterBeforeListFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeListFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error))) *MockInitializer_RegisterBeforeListFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsRequest) (*api.ListFriendsRequest, error)) error) *MockInitializer_RegisterBeforeListFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListFriendsOfFriends provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListFriendsOfFriends(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListFriendsOfFriends is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListFriendsOfFriendsRequest)(*api.ListFriendsOfFriendsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListFriendsOfFriends(fn interface{}) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call {
	return &MockInitializer_RegisterBeforeListFriendsOfFriends_Call{Call: _e.mock.On("RegisterBeforeListFriendsOfFriends", fn)}
}

func (_c *MockInitializer_RegisterBeforeListFriendsOfFriends_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error))) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListFriendsOfFriends_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListFriendsOfFriends_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListFriendsOfFriendsRequest) (*api.ListFriendsOfFriendsRequest, error)) error) *MockInitializer_RegisterBeforeListFriendsOfFriends_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListGroupUsersRequest)(*api.ListGroupUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListGroupUsers(fn interface{}) *MockInitializer_RegisterBeforeListGroupUsers_Call {
	return &MockInitializer_RegisterBeforeListGroupUsers_Call{Call: _e.mock.On("RegisterBeforeListGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforeListGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error))) *MockInitializer_RegisterBeforeListGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupUsersRequest) (*api.ListGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforeListGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListGroups provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListGroups is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListGroupsRequest)(*api.ListGroupsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListGroups(fn interface{}) *MockInitializer_RegisterBeforeListGroups_Call {
	return &MockInitializer_RegisterBeforeListGroups_Call{Call: _e.mock.On("RegisterBeforeListGroups", fn)}
}

func (_c *MockInitializer_RegisterBeforeListGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error))) *MockInitializer_RegisterBeforeListGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListGroups_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListGroups_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListGroupsRequest) (*api.ListGroupsRequest, error)) error) *MockInitializer_RegisterBeforeListGroups_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListLeaderboardRecords provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListLeaderboardRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListLeaderboardRecords is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListLeaderboardRecordsRequest)(*api.ListLeaderboardRecordsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListLeaderboardRecords(fn interface{}) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call {
	return &MockInitializer_RegisterBeforeListLeaderboardRecords_Call{Call: _e.mock.On("RegisterBeforeListLeaderboardRecords", fn)}
}

func (_c *MockInitializer_RegisterBeforeListLeaderboardRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error))) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListLeaderboardRecords_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListLeaderboardRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsRequest) (*api.ListLeaderboardRecordsRequest, error)) error) *MockInitializer_RegisterBeforeListLeaderboardRecords_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListLeaderboardRecordsAroundOwner provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListLeaderboardRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListLeaderboardRecordsAroundOwner is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListLeaderboardRecordsAroundOwnerRequest)(*api.ListLeaderboardRecordsAroundOwnerRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListLeaderboardRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call {
	return &MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call{Call: _e.mock.On("RegisterBeforeListLeaderboardRecordsAroundOwner", fn)}
}

func (_c *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error))) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListLeaderboardRecordsAroundOwnerRequest) (*api.ListLeaderboardRecordsAroundOwnerRequest, error)) error) *MockInitializer_RegisterBeforeListLeaderboardRecordsAroundOwner_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListMatches provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListMatches(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListMatches is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListMatchesRequest)(*api.ListMatchesRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListMatches(fn interface{}) *MockInitializer_RegisterBeforeListMatches_Call {
	return &MockInitializer_RegisterBeforeListMatches_Call{Call: _e.mock.On("RegisterBeforeListMatches", fn)}
}

func (_c *MockInitializer_RegisterBeforeListMatches_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error))) *MockInitializer_RegisterBeforeListMatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListMatches_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListMatches_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListMatches_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListMatchesRequest) (*api.ListMatchesRequest, error)) error) *MockInitializer_RegisterBeforeListMatches_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListNotifications provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListNotifications(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListNotifications is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListNotificationsRequest)(*api.ListNotificationsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListNotifications(fn interface{}) *MockInitializer_RegisterBeforeListNotifications_Call {
	return &MockInitializer_RegisterBeforeListNotifications_Call{Call: _e.mock.On("RegisterBeforeListNotifications", fn)}
}

func (_c *MockInitializer_RegisterBeforeListNotifications_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error))) *MockInitializer_RegisterBeforeListNotifications_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListNotifications_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListNotifications_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListNotifications_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListNotificationsRequest) (*api.ListNotificationsRequest, error)) error) *MockInitializer_RegisterBeforeListNotifications_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListStorageObjectsRequest)(*api.ListStorageObjectsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeListStorageObjects_Call {
	return &MockInitializer_RegisterBeforeListStorageObjects_Call{Call: _e.mock.On("RegisterBeforeListStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterBeforeListStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeListStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListStorageObjectsRequest) (*api.ListStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeListStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListSubscriptions provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListSubscriptions(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListSubscriptions is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListSubscriptionsRequest)(*api.ListSubscriptionsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListSubscriptions(fn interface{}) *MockInitializer_RegisterBeforeListSubscriptions_Call {
	return &MockInitializer_RegisterBeforeListSubscriptions_Call{Call: _e.mock.On("RegisterBeforeListSubscriptions", fn)}
}

func (_c *MockInitializer_RegisterBeforeListSubscriptions_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error))) *MockInitializer_RegisterBeforeListSubscriptions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListSubscriptions_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListSubscriptions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListSubscriptions_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListSubscriptionsRequest) (*api.ListSubscriptionsRequest, error)) error) *MockInitializer_RegisterBeforeListSubscriptions_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListTournamentRecords provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListTournamentRecords(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListTournamentRecords is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListTournamentRecordsRequest)(*api.ListTournamentRecordsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListTournamentRecords(fn interface{}) *MockInitializer_RegisterBeforeListTournamentRecords_Call {
	return &MockInitializer_RegisterBeforeListTournamentRecords_Call{Call: _e.mock.On("RegisterBeforeListTournamentRecords", fn)}
}

func (_c *MockInitializer_RegisterBeforeListTournamentRecords_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error))) *MockInitializer_RegisterBeforeListTournamentRecords_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListTournamentRecords_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListTournamentRecords_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListTournamentRecords_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsRequest) (*api.ListTournamentRecordsRequest, error)) error) *MockInitializer_RegisterBeforeListTournamentRecords_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListTournamentRecordsAroundOwner provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListTournamentRecordsAroundOwner(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListTournamentRecordsAroundOwner is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListTournamentRecordsAroundOwnerRequest)(*api.ListTournamentRecordsAroundOwnerRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListTournamentRecordsAroundOwner(fn interface{}) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call {
	return &MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call{Call: _e.mock.On("RegisterBeforeListTournamentRecordsAroundOwner", fn)}
}

func (_c *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error))) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentRecordsAroundOwnerRequest) (*api.ListTournamentRecordsAroundOwnerRequest, error)) error) *MockInitializer_RegisterBeforeListTournamentRecordsAroundOwner_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListTournaments provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListTournaments(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListTournaments is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListTournamentsRequest)(*api.ListTournamentsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListTournaments(fn interface{}) *MockInitializer_RegisterBeforeListTournaments_Call {
	return &MockInitializer_RegisterBeforeListTournaments_Call{Call: _e.mock.On("RegisterBeforeListTournaments", fn)}
}

func (_c *MockInitializer_RegisterBeforeListTournaments_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error))) *MockInitializer_RegisterBeforeListTournaments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListTournaments_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListTournaments_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListTournaments_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListTournamentsRequest) (*api.ListTournamentsRequest, error)) error) *MockInitializer_RegisterBeforeListTournaments_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeListUserGroups provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeListUserGroups(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeListUserGroups is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ListUserGroupsRequest)(*api.ListUserGroupsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeListUserGroups(fn interface{}) *MockInitializer_RegisterBeforeListUserGroups_Call {
	return &MockInitializer_RegisterBeforeListUserGroups_Call{Call: _e.mock.On("RegisterBeforeListUserGroups", fn)}
}

func (_c *MockInitializer_RegisterBeforeListUserGroups_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error))) *MockInitializer_RegisterBeforeListUserGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeListUserGroups_Call) Return(_a0 error) *MockInitializer_RegisterBeforeListUserGroups_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeListUserGroups_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ListUserGroupsRequest) (*api.ListUserGroupsRequest, error)) error) *MockInitializer_RegisterBeforeListUserGroups_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforePromoteGroupUsers provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforePromoteGroupUsers(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforePromoteGroupUsers is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.PromoteGroupUsersRequest)(*api.PromoteGroupUsersRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforePromoteGroupUsers(fn interface{}) *MockInitializer_RegisterBeforePromoteGroupUsers_Call {
	return &MockInitializer_RegisterBeforePromoteGroupUsers_Call{Call: _e.mock.On("RegisterBeforePromoteGroupUsers", fn)}
}

func (_c *MockInitializer_RegisterBeforePromoteGroupUsers_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error))) *MockInitializer_RegisterBeforePromoteGroupUsers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforePromoteGroupUsers_Call) Return(_a0 error) *MockInitializer_RegisterBeforePromoteGroupUsers_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforePromoteGroupUsers_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.PromoteGroupUsersRequest) (*api.PromoteGroupUsersRequest, error)) error) *MockInitializer_RegisterBeforePromoteGroupUsers_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeReadStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeReadStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeReadStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ReadStorageObjectsRequest)(*api.ReadStorageObjectsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeReadStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeReadStorageObjects_Call {
	return &MockInitializer_RegisterBeforeReadStorageObjects_Call{Call: _e.mock.On("RegisterBeforeReadStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterBeforeReadStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeReadStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeReadStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeReadStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeReadStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ReadStorageObjectsRequest) (*api.ReadStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeReadStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeRt provides a mock function with given fields: id, fn
func (_m *MockInitializer) RegisterBeforeRt(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)) error {
	ret := _m.Called(id, fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)) error); ok {
		r0 = rf(id, fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeRt is a helper method to define mock.On call
//   - id string
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *rtapi.Envelope)(*rtapi.Envelope , error)
func (_e *MockInitializer_Expecter) RegisterBeforeRt(id interface{}, fn interface{}) *MockInitializer_RegisterBeforeRt_Call {
	return &MockInitializer_RegisterBeforeRt_Call{Call: _e.mock.On("RegisterBeforeRt", id, fn)}
}

func (_c *MockInitializer_RegisterBeforeRt_Call) Run(run func(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error))) *MockInitializer_RegisterBeforeRt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeRt_Call) Return(_a0 error) *MockInitializer_RegisterBeforeRt_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeRt_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *rtapi.Envelope) (*rtapi.Envelope, error)) error) *MockInitializer_RegisterBeforeRt_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeSessionLogout provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeSessionLogout(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeSessionLogout is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SessionLogoutRequest)(*api.SessionLogoutRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeSessionLogout(fn interface{}) *MockInitializer_RegisterBeforeSessionLogout_Call {
	return &MockInitializer_RegisterBeforeSessionLogout_Call{Call: _e.mock.On("RegisterBeforeSessionLogout", fn)}
}

func (_c *MockInitializer_RegisterBeforeSessionLogout_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error))) *MockInitializer_RegisterBeforeSessionLogout_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeSessionLogout_Call) Return(_a0 error) *MockInitializer_RegisterBeforeSessionLogout_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeSessionLogout_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionLogoutRequest) (*api.SessionLogoutRequest, error)) error) *MockInitializer_RegisterBeforeSessionLogout_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeSessionRefresh provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeSessionRefresh(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeSessionRefresh is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.SessionRefreshRequest)(*api.SessionRefreshRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeSessionRefresh(fn interface{}) *MockInitializer_RegisterBeforeSessionRefresh_Call {
	return &MockInitializer_RegisterBeforeSessionRefresh_Call{Call: _e.mock.On("RegisterBeforeSessionRefresh", fn)}
}

func (_c *MockInitializer_RegisterBeforeSessionRefresh_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error))) *MockInitializer_RegisterBeforeSessionRefresh_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeSessionRefresh_Call) Return(_a0 error) *MockInitializer_RegisterBeforeSessionRefresh_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeSessionRefresh_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.SessionRefreshRequest) (*api.SessionRefreshRequest, error)) error) *MockInitializer_RegisterBeforeSessionRefresh_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountApple)(*api.AccountApple , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkApple(fn interface{}) *MockInitializer_RegisterBeforeUnlinkApple_Call {
	return &MockInitializer_RegisterBeforeUnlinkApple_Call{Call: _e.mock.On("RegisterBeforeUnlinkApple", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error))) *MockInitializer_RegisterBeforeUnlinkApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountApple) (*api.AccountApple, error)) error) *MockInitializer_RegisterBeforeUnlinkApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkCustom provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkCustom(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkCustom is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountCustom)(*api.AccountCustom , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkCustom(fn interface{}) *MockInitializer_RegisterBeforeUnlinkCustom_Call {
	return &MockInitializer_RegisterBeforeUnlinkCustom_Call{Call: _e.mock.On("RegisterBeforeUnlinkCustom", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkCustom_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error))) *MockInitializer_RegisterBeforeUnlinkCustom_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkCustom_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkCustom_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkCustom_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountCustom) (*api.AccountCustom, error)) error) *MockInitializer_RegisterBeforeUnlinkCustom_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkDevice provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkDevice(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkDevice is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountDevice)(*api.AccountDevice , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkDevice(fn interface{}) *MockInitializer_RegisterBeforeUnlinkDevice_Call {
	return &MockInitializer_RegisterBeforeUnlinkDevice_Call{Call: _e.mock.On("RegisterBeforeUnlinkDevice", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkDevice_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error))) *MockInitializer_RegisterBeforeUnlinkDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkDevice_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkDevice_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountDevice) (*api.AccountDevice, error)) error) *MockInitializer_RegisterBeforeUnlinkDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkEmail provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkEmail(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkEmail is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountEmail)(*api.AccountEmail , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkEmail(fn interface{}) *MockInitializer_RegisterBeforeUnlinkEmail_Call {
	return &MockInitializer_RegisterBeforeUnlinkEmail_Call{Call: _e.mock.On("RegisterBeforeUnlinkEmail", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkEmail_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error))) *MockInitializer_RegisterBeforeUnlinkEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkEmail_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkEmail_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkEmail_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountEmail) (*api.AccountEmail, error)) error) *MockInitializer_RegisterBeforeUnlinkEmail_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkFacebook provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkFacebook(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkFacebook is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebook)(*api.AccountFacebook , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkFacebook(fn interface{}) *MockInitializer_RegisterBeforeUnlinkFacebook_Call {
	return &MockInitializer_RegisterBeforeUnlinkFacebook_Call{Call: _e.mock.On("RegisterBeforeUnlinkFacebook", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkFacebook_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error))) *MockInitializer_RegisterBeforeUnlinkFacebook_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkFacebook_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkFacebook_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkFacebook_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebook) (*api.AccountFacebook, error)) error) *MockInitializer_RegisterBeforeUnlinkFacebook_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkFacebookInstantGame provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkFacebookInstantGame(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkFacebookInstantGame is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountFacebookInstantGame)(*api.AccountFacebookInstantGame , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkFacebookInstantGame(fn interface{}) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call {
	return &MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call{Call: _e.mock.On("RegisterBeforeUnlinkFacebookInstantGame", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error))) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountFacebookInstantGame) (*api.AccountFacebookInstantGame, error)) error) *MockInitializer_RegisterBeforeUnlinkFacebookInstantGame_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkGameCenter provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkGameCenter(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkGameCenter is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGameCenter)(*api.AccountGameCenter , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkGameCenter(fn interface{}) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call {
	return &MockInitializer_RegisterBeforeUnlinkGameCenter_Call{Call: _e.mock.On("RegisterBeforeUnlinkGameCenter", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkGameCenter_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error))) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkGameCenter_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkGameCenter_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGameCenter) (*api.AccountGameCenter, error)) error) *MockInitializer_RegisterBeforeUnlinkGameCenter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountGoogle)(*api.AccountGoogle , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkGoogle(fn interface{}) *MockInitializer_RegisterBeforeUnlinkGoogle_Call {
	return &MockInitializer_RegisterBeforeUnlinkGoogle_Call{Call: _e.mock.On("RegisterBeforeUnlinkGoogle", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error))) *MockInitializer_RegisterBeforeUnlinkGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountGoogle) (*api.AccountGoogle, error)) error) *MockInitializer_RegisterBeforeUnlinkGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUnlinkSteam provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUnlinkSteam(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUnlinkSteam is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.AccountSteam)(*api.AccountSteam , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUnlinkSteam(fn interface{}) *MockInitializer_RegisterBeforeUnlinkSteam_Call {
	return &MockInitializer_RegisterBeforeUnlinkSteam_Call{Call: _e.mock.On("RegisterBeforeUnlinkSteam", fn)}
}

func (_c *MockInitializer_RegisterBeforeUnlinkSteam_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error))) *MockInitializer_RegisterBeforeUnlinkSteam_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkSteam_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUnlinkSteam_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUnlinkSteam_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.AccountSteam) (*api.AccountSteam, error)) error) *MockInitializer_RegisterBeforeUnlinkSteam_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUpdateAccount provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUpdateAccount(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUpdateAccount is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateAccountRequest)(*api.UpdateAccountRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUpdateAccount(fn interface{}) *MockInitializer_RegisterBeforeUpdateAccount_Call {
	return &MockInitializer_RegisterBeforeUpdateAccount_Call{Call: _e.mock.On("RegisterBeforeUpdateAccount", fn)}
}

func (_c *MockInitializer_RegisterBeforeUpdateAccount_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error))) *MockInitializer_RegisterBeforeUpdateAccount_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUpdateAccount_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUpdateAccount_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUpdateAccount_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateAccountRequest) (*api.UpdateAccountRequest, error)) error) *MockInitializer_RegisterBeforeUpdateAccount_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeUpdateGroup provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeUpdateGroup(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeUpdateGroup is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.UpdateGroupRequest)(*api.UpdateGroupRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeUpdateGroup(fn interface{}) *MockInitializer_RegisterBeforeUpdateGroup_Call {
	return &MockInitializer_RegisterBeforeUpdateGroup_Call{Call: _e.mock.On("RegisterBeforeUpdateGroup", fn)}
}

func (_c *MockInitializer_RegisterBeforeUpdateGroup_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error))) *MockInitializer_RegisterBeforeUpdateGroup_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeUpdateGroup_Call) Return(_a0 error) *MockInitializer_RegisterBeforeUpdateGroup_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeUpdateGroup_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.UpdateGroupRequest) (*api.UpdateGroupRequest, error)) error) *MockInitializer_RegisterBeforeUpdateGroup_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeValidatePurchaseApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeValidatePurchaseApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeValidatePurchaseApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseAppleRequest)(*api.ValidatePurchaseAppleRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseApple(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call {
	return &MockInitializer_RegisterBeforeValidatePurchaseApple_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseApple", fn)}
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseAppleRequest) (*api.ValidatePurchaseAppleRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeValidatePurchaseFacebookInstant provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeValidatePurchaseFacebookInstant(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeValidatePurchaseFacebookInstant is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseFacebookInstantRequest)(*api.ValidatePurchaseFacebookInstantRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseFacebookInstant(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call {
	return &MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseFacebookInstant", fn)}
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseFacebookInstantRequest) (*api.ValidatePurchaseFacebookInstantRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseFacebookInstant_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeValidatePurchaseGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeValidatePurchaseGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeValidatePurchaseGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseGoogleRequest)(*api.ValidatePurchaseGoogleRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseGoogle(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call {
	return &MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseGoogle", fn)}
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseGoogleRequest) (*api.ValidatePurchaseGoogleRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeValidatePurchaseHuawei provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeValidatePurchaseHuawei(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeValidatePurchaseHuawei is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatePurchaseHuaweiRequest)(*api.ValidatePurchaseHuaweiRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeValidatePurchaseHuawei(fn interface{}) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call {
	return &MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call{Call: _e.mock.On("RegisterBeforeValidatePurchaseHuawei", fn)}
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error))) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatePurchaseHuaweiRequest) (*api.ValidatePurchaseHuaweiRequest, error)) error) *MockInitializer_RegisterBeforeValidatePurchaseHuawei_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeValidateSubscriptionApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeValidateSubscriptionApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeValidateSubscriptionApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionAppleRequest)(*api.ValidateSubscriptionAppleRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeValidateSubscriptionApple(fn interface{}) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call {
	return &MockInitializer_RegisterBeforeValidateSubscriptionApple_Call{Call: _e.mock.On("RegisterBeforeValidateSubscriptionApple", fn)}
}

func (_c *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error))) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionAppleRequest) (*api.ValidateSubscriptionAppleRequest, error)) error) *MockInitializer_RegisterBeforeValidateSubscriptionApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeValidateSubscriptionGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeValidateSubscriptionGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeValidateSubscriptionGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidateSubscriptionGoogleRequest)(*api.ValidateSubscriptionGoogleRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeValidateSubscriptionGoogle(fn interface{}) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call {
	return &MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call{Call: _e.mock.On("RegisterBeforeValidateSubscriptionGoogle", fn)}
}

func (_c *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error))) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call) Return(_a0 error) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidateSubscriptionGoogleRequest) (*api.ValidateSubscriptionGoogleRequest, error)) error) *MockInitializer_RegisterBeforeValidateSubscriptionGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeWriteLeaderboardRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeWriteLeaderboardRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeWriteLeaderboardRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.WriteLeaderboardRecordRequest)(*api.WriteLeaderboardRecordRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeWriteLeaderboardRecord(fn interface{}) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call {
	return &MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call{Call: _e.mock.On("RegisterBeforeWriteLeaderboardRecord", fn)}
}

func (_c *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error))) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteLeaderboardRecordRequest) (*api.WriteLeaderboardRecordRequest, error)) error) *MockInitializer_RegisterBeforeWriteLeaderboardRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeWriteStorageObjects provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeWriteStorageObjects(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeWriteStorageObjects is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.WriteStorageObjectsRequest)(*api.WriteStorageObjectsRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeWriteStorageObjects(fn interface{}) *MockInitializer_RegisterBeforeWriteStorageObjects_Call {
	return &MockInitializer_RegisterBeforeWriteStorageObjects_Call{Call: _e.mock.On("RegisterBeforeWriteStorageObjects", fn)}
}

func (_c *MockInitializer_RegisterBeforeWriteStorageObjects_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error))) *MockInitializer_RegisterBeforeWriteStorageObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeWriteStorageObjects_Call) Return(_a0 error) *MockInitializer_RegisterBeforeWriteStorageObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeWriteStorageObjects_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteStorageObjectsRequest) (*api.WriteStorageObjectsRequest, error)) error) *MockInitializer_RegisterBeforeWriteStorageObjects_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterBeforeWriteTournamentRecord provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterBeforeWriteTournamentRecord(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterBeforeWriteTournamentRecord is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.WriteTournamentRecordRequest)(*api.WriteTournamentRecordRequest , error)
func (_e *MockInitializer_Expecter) RegisterBeforeWriteTournamentRecord(fn interface{}) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call {
	return &MockInitializer_RegisterBeforeWriteTournamentRecord_Call{Call: _e.mock.On("RegisterBeforeWriteTournamentRecord", fn)}
}

func (_c *MockInitializer_RegisterBeforeWriteTournamentRecord_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error))) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterBeforeWriteTournamentRecord_Call) Return(_a0 error) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterBeforeWriteTournamentRecord_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.WriteTournamentRecordRequest) (*api.WriteTournamentRecordRequest, error)) error) *MockInitializer_RegisterBeforeWriteTournamentRecord_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterEvent provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterEvent(fn func(context.Context, runtime.Logger, *api.Event)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *api.Event)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterEvent is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *api.Event)
func (_e *MockInitializer_Expecter) RegisterEvent(fn interface{}) *MockInitializer_RegisterEvent_Call {
	return &MockInitializer_RegisterEvent_Call{Call: _e.mock.On("RegisterEvent", fn)}
}

func (_c *MockInitializer_RegisterEvent_Call) Run(run func(fn func(context.Context, runtime.Logger, *api.Event))) *MockInitializer_RegisterEvent_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *api.Event)))
	})
	return _c
}

func (_c *MockInitializer_RegisterEvent_Call) Return(_a0 error) *MockInitializer_RegisterEvent_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterEvent_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *api.Event)) error) *MockInitializer_RegisterEvent_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterEventSessionEnd provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterEventSessionEnd(fn func(context.Context, runtime.Logger, *api.Event)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *api.Event)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterEventSessionEnd is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *api.Event)
func (_e *MockInitializer_Expecter) RegisterEventSessionEnd(fn interface{}) *MockInitializer_RegisterEventSessionEnd_Call {
	return &MockInitializer_RegisterEventSessionEnd_Call{Call: _e.mock.On("RegisterEventSessionEnd", fn)}
}

func (_c *MockInitializer_RegisterEventSessionEnd_Call) Run(run func(fn func(context.Context, runtime.Logger, *api.Event))) *MockInitializer_RegisterEventSessionEnd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *api.Event)))
	})
	return _c
}

func (_c *MockInitializer_RegisterEventSessionEnd_Call) Return(_a0 error) *MockInitializer_RegisterEventSessionEnd_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterEventSessionEnd_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *api.Event)) error) *MockInitializer_RegisterEventSessionEnd_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterEventSessionStart provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterEventSessionStart(fn func(context.Context, runtime.Logger, *api.Event)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *api.Event)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterEventSessionStart is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *api.Event)
func (_e *MockInitializer_Expecter) RegisterEventSessionStart(fn interface{}) *MockInitializer_RegisterEventSessionStart_Call {
	return &MockInitializer_RegisterEventSessionStart_Call{Call: _e.mock.On("RegisterEventSessionStart", fn)}
}

func (_c *MockInitializer_RegisterEventSessionStart_Call) Run(run func(fn func(context.Context, runtime.Logger, *api.Event))) *MockInitializer_RegisterEventSessionStart_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *api.Event)))
	})
	return _c
}

func (_c *MockInitializer_RegisterEventSessionStart_Call) Return(_a0 error) *MockInitializer_RegisterEventSessionStart_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterEventSessionStart_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *api.Event)) error) *MockInitializer_RegisterEventSessionStart_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterFleetManager provides a mock function with given fields: fleetManagerInit
func (_m *MockInitializer) RegisterFleetManager(fleetManagerInit runtime.FleetManagerInitializer) error {
	ret := _m.Called(fleetManagerInit)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(runtime.FleetManagerInitializer) error); ok {
		r0 = rf(fleetManagerInit)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterFleetManager is a helper method to define mock.On call
//   - fleetManagerInit runtime.FleetManagerInitializer
func (_e *MockInitializer_Expecter) RegisterFleetManager(fleetManagerInit interface{}) *MockInitializer_RegisterFleetManager_Call {
	return &MockInitializer_RegisterFleetManager_Call{Call: _e.mock.On("RegisterFleetManager", fleetManagerInit)}
}

func (_c *MockInitializer_RegisterFleetManager_Call) Run(run func(fleetManagerInit runtime.FleetManagerInitializer)) *MockInitializer_RegisterFleetManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(runtime.FleetManagerInitializer))
	})
	return _c
}

func (_c *MockInitializer_RegisterFleetManager_Call) Return(_a0 error) *MockInitializer_RegisterFleetManager_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterFleetManager_Call) RunAndReturn(run func(runtime.FleetManagerInitializer) error) *MockInitializer_RegisterFleetManager_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterHttp provides a mock function with given fields: pathPattern, handler, methods
func (_m *MockInitializer) RegisterHttp(pathPattern string, handler func(http.ResponseWriter, *http.Request), methods ...string) error {
	_va := make([]interface{}, len(methods))
	for _i := range methods {
		_va[_i] = methods[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, pathPattern, handler)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, func(http.ResponseWriter, *http.Request), ...string) error); ok {
		r0 = rf(pathPattern, handler, methods...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterHttp is a helper method to define mock.On call
//   - pathPattern string
//   - handler func(http.ResponseWriter , *http.Request)
//   - methods ...string
func (_e *MockInitializer_Expecter) RegisterHttp(pathPattern interface{}, handler interface{}, methods ...interface{}) *MockInitializer_RegisterHttp_Call {
	return &MockInitializer_RegisterHttp_Call{Call: _e.mock.On("RegisterHttp",
		append([]interface{}{pathPattern, handler}, methods...)...)}
}

func (_c *MockInitializer_RegisterHttp_Call) Run(run func(pathPattern string, handler func(http.ResponseWriter, *http.Request), methods ...string)) *MockInitializer_RegisterHttp_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(string), args[1].(func(http.ResponseWriter, *http.Request)), variadicArgs...)
	})
	return _c
}

func (_c *MockInitializer_RegisterHttp_Call) Return(_a0 error) *MockInitializer_RegisterHttp_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterHttp_Call) RunAndReturn(run func(string, func(http.ResponseWriter, *http.Request), ...string) error) *MockInitializer_RegisterHttp_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterLeaderboardReset provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterLeaderboardReset(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterLeaderboardReset is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Leaderboard , int64) error
func (_e *MockInitializer_Expecter) RegisterLeaderboardReset(fn interface{}) *MockInitializer_RegisterLeaderboardReset_Call {
	return &MockInitializer_RegisterLeaderboardReset_Call{Call: _e.mock.On("RegisterLeaderboardReset", fn)}
}

func (_c *MockInitializer_RegisterLeaderboardReset_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error)) *MockInitializer_RegisterLeaderboardReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterLeaderboardReset_Call) Return(_a0 error) *MockInitializer_RegisterLeaderboardReset_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterLeaderboardReset_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Leaderboard, int64) error) error) *MockInitializer_RegisterLeaderboardReset_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterMatch provides a mock function with given fields: name, fn
func (_m *MockInitializer) RegisterMatch(name string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)) error {
	ret := _m.Called(name, fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)) error); ok {
		r0 = rf(name, fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterMatch is a helper method to define mock.On call
//   - name string
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule)(runtime.Match , error)
func (_e *MockInitializer_Expecter) RegisterMatch(name interface{}, fn interface{}) *MockInitializer_RegisterMatch_Call {
	return &MockInitializer_RegisterMatch_Call{Call: _e.mock.On("RegisterMatch", name, fn)}
}

func (_c *MockInitializer_RegisterMatch_Call) Run(run func(name string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error))) *MockInitializer_RegisterMatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterMatch_Call) Return(_a0 error) *MockInitializer_RegisterMatch_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterMatch_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule) (runtime.Match, error)) error) *MockInitializer_RegisterMatch_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterMatchmakerMatched provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterMatchmakerMatched(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterMatchmakerMatched is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , []runtime.MatchmakerEntry)(string , error)
func (_e *MockInitializer_Expecter) RegisterMatchmakerMatched(fn interface{}) *MockInitializer_RegisterMatchmakerMatched_Call {
	return &MockInitializer_RegisterMatchmakerMatched_Call{Call: _e.mock.On("RegisterMatchmakerMatched", fn)}
}

func (_c *MockInitializer_RegisterMatchmakerMatched_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error))) *MockInitializer_RegisterMatchmakerMatched_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterMatchmakerMatched_Call) Return(_a0 error) *MockInitializer_RegisterMatchmakerMatched_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterMatchmakerMatched_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, []runtime.MatchmakerEntry) (string, error)) error) *MockInitializer_RegisterMatchmakerMatched_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterMatchmakerOverride provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterMatchmakerOverride(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterMatchmakerOverride is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry
func (_e *MockInitializer_Expecter) RegisterMatchmakerOverride(fn interface{}) *MockInitializer_RegisterMatchmakerOverride_Call {
	return &MockInitializer_RegisterMatchmakerOverride_Call{Call: _e.mock.On("RegisterMatchmakerOverride", fn)}
}

func (_c *MockInitializer_RegisterMatchmakerOverride_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry)) *MockInitializer_RegisterMatchmakerOverride_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry))
	})
	return _c
}

func (_c *MockInitializer_RegisterMatchmakerOverride_Call) Return(_a0 error) *MockInitializer_RegisterMatchmakerOverride_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterMatchmakerOverride_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, [][]runtime.MatchmakerEntry) [][]runtime.MatchmakerEntry) error) *MockInitializer_RegisterMatchmakerOverride_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterPurchaseNotificationApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterPurchaseNotificationApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterPurchaseNotificationApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedPurchase , string) error
func (_e *MockInitializer_Expecter) RegisterPurchaseNotificationApple(fn interface{}) *MockInitializer_RegisterPurchaseNotificationApple_Call {
	return &MockInitializer_RegisterPurchaseNotificationApple_Call{Call: _e.mock.On("RegisterPurchaseNotificationApple", fn)}
}

func (_c *MockInitializer_RegisterPurchaseNotificationApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error)) *MockInitializer_RegisterPurchaseNotificationApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterPurchaseNotificationApple_Call) Return(_a0 error) *MockInitializer_RegisterPurchaseNotificationApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterPurchaseNotificationApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error) *MockInitializer_RegisterPurchaseNotificationApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterPurchaseNotificationGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterPurchaseNotificationGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterPurchaseNotificationGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedPurchase , string) error
func (_e *MockInitializer_Expecter) RegisterPurchaseNotificationGoogle(fn interface{}) *MockInitializer_RegisterPurchaseNotificationGoogle_Call {
	return &MockInitializer_RegisterPurchaseNotificationGoogle_Call{Call: _e.mock.On("RegisterPurchaseNotificationGoogle", fn)}
}

func (_c *MockInitializer_RegisterPurchaseNotificationGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error)) *MockInitializer_RegisterPurchaseNotificationGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterPurchaseNotificationGoogle_Call) Return(_a0 error) *MockInitializer_RegisterPurchaseNotificationGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterPurchaseNotificationGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedPurchase, string) error) error) *MockInitializer_RegisterPurchaseNotificationGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterRpc provides a mock function with given fields: id, fn
func (_m *MockInitializer) RegisterRpc(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)) error {
	ret := _m.Called(id, fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)) error); ok {
		r0 = rf(id, fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterRpc is a helper method to define mock.On call
//   - id string
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , string)(string , error)
func (_e *MockInitializer_Expecter) RegisterRpc(id interface{}, fn interface{}) *MockInitializer_RegisterRpc_Call {
	return &MockInitializer_RegisterRpc_Call{Call: _e.mock.On("RegisterRpc", id, fn)}
}

func (_c *MockInitializer_RegisterRpc_Call) Run(run func(id string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error))) *MockInitializer_RegisterRpc_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)))
	})
	return _c
}

func (_c *MockInitializer_RegisterRpc_Call) Return(_a0 error) *MockInitializer_RegisterRpc_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterRpc_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, string) (string, error)) error) *MockInitializer_RegisterRpc_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterShutdown provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterShutdown(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterShutdown is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule)
func (_e *MockInitializer_Expecter) RegisterShutdown(fn interface{}) *MockInitializer_RegisterShutdown_Call {
	return &MockInitializer_RegisterShutdown_Call{Call: _e.mock.On("RegisterShutdown", fn)}
}

func (_c *MockInitializer_RegisterShutdown_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule))) *MockInitializer_RegisterShutdown_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)))
	})
	return _c
}

func (_c *MockInitializer_RegisterShutdown_Call) Return(_a0 error) *MockInitializer_RegisterShutdown_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterShutdown_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule)) error) *MockInitializer_RegisterShutdown_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterStorageIndex provides a mock function with given fields: name, collection, key, fields, sortableFields, maxEntries, indexOnly
func (_m *MockInitializer) RegisterStorageIndex(name string, collection string, key string, fields []string, sortableFields []string, maxEntries int, indexOnly bool) error {
	ret := _m.Called(name, collection, key, fields, sortableFields, maxEntries, indexOnly)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, string, string, []string, []string, int, bool) error); ok {
		r0 = rf(name, collection, key, fields, sortableFields, maxEntries, indexOnly)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterStorageIndex is a helper method to define mock.On call
//   - name string
//   - collection string
//   - key string
//   - fields []string
//   - sortableFields []string
//   - maxEntries int
//   - indexOnly bool
func (_e *MockInitializer_Expecter) RegisterStorageIndex(name interface{}, collection interface{}, key interface{}, fields interface{}, sortableFields interface{}, maxEntries interface{}, indexOnly interface{}) *MockInitializer_RegisterStorageIndex_Call {
	return &MockInitializer_RegisterStorageIndex_Call{Call: _e.mock.On("RegisterStorageIndex", name, collection, key, fields, sortableFields, maxEntries, indexOnly)}
}

func (_c *MockInitializer_RegisterStorageIndex_Call) Run(run func(name string, collection string, key string, fields []string, sortableFields []string, maxEntries int, indexOnly bool)) *MockInitializer_RegisterStorageIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string), args[3].([]string), args[4].([]string), args[5].(int), args[6].(bool))
	})
	return _c
}

func (_c *MockInitializer_RegisterStorageIndex_Call) Return(_a0 error) *MockInitializer_RegisterStorageIndex_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterStorageIndex_Call) RunAndReturn(run func(string, string, string, []string, []string, int, bool) error) *MockInitializer_RegisterStorageIndex_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterStorageIndexFilter provides a mock function with given fields: indexName, fn
func (_m *MockInitializer) RegisterStorageIndexFilter(indexName string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool) error {
	ret := _m.Called(indexName, fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool) error); ok {
		r0 = rf(indexName, fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterStorageIndexFilter is a helper method to define mock.On call
//   - indexName string
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *runtime.StorageWrite) bool
func (_e *MockInitializer_Expecter) RegisterStorageIndexFilter(indexName interface{}, fn interface{}) *MockInitializer_RegisterStorageIndexFilter_Call {
	return &MockInitializer_RegisterStorageIndexFilter_Call{Call: _e.mock.On("RegisterStorageIndexFilter", indexName, fn)}
}

func (_c *MockInitializer_RegisterStorageIndexFilter_Call) Run(run func(indexName string, fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool)) *MockInitializer_RegisterStorageIndexFilter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool))
	})
	return _c
}

func (_c *MockInitializer_RegisterStorageIndexFilter_Call) Return(_a0 error) *MockInitializer_RegisterStorageIndexFilter_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterStorageIndexFilter_Call) RunAndReturn(run func(string, func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *runtime.StorageWrite) bool) error) *MockInitializer_RegisterStorageIndexFilter_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterSubscriptionNotificationApple provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterSubscriptionNotificationApple(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterSubscriptionNotificationApple is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedSubscription , string) error
func (_e *MockInitializer_Expecter) RegisterSubscriptionNotificationApple(fn interface{}) *MockInitializer_RegisterSubscriptionNotificationApple_Call {
	return &MockInitializer_RegisterSubscriptionNotificationApple_Call{Call: _e.mock.On("RegisterSubscriptionNotificationApple", fn)}
}

func (_c *MockInitializer_RegisterSubscriptionNotificationApple_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error)) *MockInitializer_RegisterSubscriptionNotificationApple_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterSubscriptionNotificationApple_Call) Return(_a0 error) *MockInitializer_RegisterSubscriptionNotificationApple_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterSubscriptionNotificationApple_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error) *MockInitializer_RegisterSubscriptionNotificationApple_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterSubscriptionNotificationGoogle provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterSubscriptionNotificationGoogle(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterSubscriptionNotificationGoogle is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.ValidatedSubscription , string) error
func (_e *MockInitializer_Expecter) RegisterSubscriptionNotificationGoogle(fn interface{}) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call {
	return &MockInitializer_RegisterSubscriptionNotificationGoogle_Call{Call: _e.mock.On("RegisterSubscriptionNotificationGoogle", fn)}
}

func (_c *MockInitializer_RegisterSubscriptionNotificationGoogle_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error)) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterSubscriptionNotificationGoogle_Call) Return(_a0 error) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterSubscriptionNotificationGoogle_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.ValidatedSubscription, string) error) error) *MockInitializer_RegisterSubscriptionNotificationGoogle_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterTournamentEnd provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterTournamentEnd(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterTournamentEnd is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Tournament , int64 , int64) error
func (_e *MockInitializer_Expecter) RegisterTournamentEnd(fn interface{}) *MockInitializer_RegisterTournamentEnd_Call {
	return &MockInitializer_RegisterTournamentEnd_Call{Call: _e.mock.On("RegisterTournamentEnd", fn)}
}

func (_c *MockInitializer_RegisterTournamentEnd_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error)) *MockInitializer_RegisterTournamentEnd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterTournamentEnd_Call) Return(_a0 error) *MockInitializer_RegisterTournamentEnd_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterTournamentEnd_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error) *MockInitializer_RegisterTournamentEnd_Call {
	_c.Call.Return(run)
	return _c
}

// RegisterTournamentReset provides a mock function with given fields: fn
func (_m *MockInitializer) RegisterTournamentReset(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error {
	ret := _m.Called(fn)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error); ok {
		r0 = rf(fn)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// RegisterTournamentReset is a helper method to define mock.On call
//   - fn func(context.Context , runtime.Logger , *sql.DB , runtime.NakamaModule , *api.Tournament , int64 , int64) error
func (_e *MockInitializer_Expecter) RegisterTournamentReset(fn interface{}) *MockInitializer_RegisterTournamentReset_Call {
	return &MockInitializer_RegisterTournamentReset_Call{Call: _e.mock.On("RegisterTournamentReset", fn)}
}

func (_c *MockInitializer_RegisterTournamentReset_Call) Run(run func(fn func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error)) *MockInitializer_RegisterTournamentReset_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error))
	})
	return _c
}

func (_c *MockInitializer_RegisterTournamentReset_Call) Return(_a0 error) *MockInitializer_RegisterTournamentReset_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockInitializer_RegisterTournamentReset_Call) RunAndReturn(run func(func(context.Context, runtime.Logger, *sql.DB, runtime.NakamaModule, *api.Tournament, int64, int64) error) error) *MockInitializer_RegisterTournamentReset_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockInitializer creates a new instance of MockInitializer. 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 NewMockInitializer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInitializer {
	mock := &MockInitializer{}
	mock.Mock.Test(t)

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

	return mock
}
