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

package sessionutil

import (
	context "context"

	semver "github.com/blang/semver/v4"
	mock "github.com/stretchr/testify/mock"

	time "time"
)

// MockSession is an autogenerated mock type for the SessionInterface type
type MockSession struct {
	mock.Mock
}

type MockSession_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSession) EXPECT() *MockSession_Expecter {
	return &MockSession_Expecter{mock: &_m.Mock}
}

// Disconnected provides a mock function with given fields:
func (_m *MockSession) Disconnected() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// Disconnected is a helper method to define mock.On call
func (_e *MockSession_Expecter) Disconnected() *MockSession_Disconnected_Call {
	return &MockSession_Disconnected_Call{Call: _e.mock.On("Disconnected")}
}

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

func (_c *MockSession_Disconnected_Call) Return(_a0 bool) *MockSession_Disconnected_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSession_Disconnected_Call) RunAndReturn(run func() bool) *MockSession_Disconnected_Call {
	_c.Call.Return(run)
	return _c
}

// ForceActiveStandby provides a mock function with given fields: activateFunc
func (_m *MockSession) ForceActiveStandby(activateFunc func() error) error {
	ret := _m.Called(activateFunc)

	var r0 error
	if rf, ok := ret.Get(0).(func(func() error) error); ok {
		r0 = rf(activateFunc)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ForceActiveStandby is a helper method to define mock.On call
//   - activateFunc func() error
func (_e *MockSession_Expecter) ForceActiveStandby(activateFunc interface{}) *MockSession_ForceActiveStandby_Call {
	return &MockSession_ForceActiveStandby_Call{Call: _e.mock.On("ForceActiveStandby", activateFunc)}
}

func (_c *MockSession_ForceActiveStandby_Call) Run(run func(activateFunc func() error)) *MockSession_ForceActiveStandby_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func() error))
	})
	return _c
}

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

func (_c *MockSession_ForceActiveStandby_Call) RunAndReturn(run func(func() error) error) *MockSession_ForceActiveStandby_Call {
	_c.Call.Return(run)
	return _c
}

// GetAddress provides a mock function with given fields:
func (_m *MockSession) GetAddress() string {
	ret := _m.Called()

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

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

// GetAddress is a helper method to define mock.On call
func (_e *MockSession_Expecter) GetAddress() *MockSession_GetAddress_Call {
	return &MockSession_GetAddress_Call{Call: _e.mock.On("GetAddress")}
}

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

func (_c *MockSession_GetAddress_Call) Return(_a0 string) *MockSession_GetAddress_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSession_GetAddress_Call) RunAndReturn(run func() string) *MockSession_GetAddress_Call {
	_c.Call.Return(run)
	return _c
}

// GetServerID provides a mock function with given fields:
func (_m *MockSession) GetServerID() int64 {
	ret := _m.Called()

	var r0 int64
	if rf, ok := ret.Get(0).(func() int64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int64)
	}

	return r0
}

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

// GetServerID is a helper method to define mock.On call
func (_e *MockSession_Expecter) GetServerID() *MockSession_GetServerID_Call {
	return &MockSession_GetServerID_Call{Call: _e.mock.On("GetServerID")}
}

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

func (_c *MockSession_GetServerID_Call) Return(_a0 int64) *MockSession_GetServerID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSession_GetServerID_Call) RunAndReturn(run func() int64) *MockSession_GetServerID_Call {
	_c.Call.Return(run)
	return _c
}

// GetSessions provides a mock function with given fields: prefix
func (_m *MockSession) GetSessions(prefix string) (map[string]*Session, int64, error) {
	ret := _m.Called(prefix)

	var r0 map[string]*Session
	var r1 int64
	var r2 error
	if rf, ok := ret.Get(0).(func(string) (map[string]*Session, int64, error)); ok {
		return rf(prefix)
	}
	if rf, ok := ret.Get(0).(func(string) map[string]*Session); ok {
		r0 = rf(prefix)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*Session)
		}
	}

	if rf, ok := ret.Get(1).(func(string) int64); ok {
		r1 = rf(prefix)
	} else {
		r1 = ret.Get(1).(int64)
	}

	if rf, ok := ret.Get(2).(func(string) error); ok {
		r2 = rf(prefix)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetSessions is a helper method to define mock.On call
//   - prefix string
func (_e *MockSession_Expecter) GetSessions(prefix interface{}) *MockSession_GetSessions_Call {
	return &MockSession_GetSessions_Call{Call: _e.mock.On("GetSessions", prefix)}
}

func (_c *MockSession_GetSessions_Call) Run(run func(prefix string)) *MockSession_GetSessions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *MockSession_GetSessions_Call) Return(_a0 map[string]*Session, _a1 int64, _a2 error) *MockSession_GetSessions_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockSession_GetSessions_Call) RunAndReturn(run func(string) (map[string]*Session, int64, error)) *MockSession_GetSessions_Call {
	_c.Call.Return(run)
	return _c
}

// GetSessionsWithVersionRange provides a mock function with given fields: prefix, r
func (_m *MockSession) GetSessionsWithVersionRange(prefix string, r semver.Range) (map[string]*Session, int64, error) {
	ret := _m.Called(prefix, r)

	var r0 map[string]*Session
	var r1 int64
	var r2 error
	if rf, ok := ret.Get(0).(func(string, semver.Range) (map[string]*Session, int64, error)); ok {
		return rf(prefix, r)
	}
	if rf, ok := ret.Get(0).(func(string, semver.Range) map[string]*Session); ok {
		r0 = rf(prefix, r)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]*Session)
		}
	}

	if rf, ok := ret.Get(1).(func(string, semver.Range) int64); ok {
		r1 = rf(prefix, r)
	} else {
		r1 = ret.Get(1).(int64)
	}

	if rf, ok := ret.Get(2).(func(string, semver.Range) error); ok {
		r2 = rf(prefix, r)
	} else {
		r2 = ret.Error(2)
	}

	return r0, r1, r2
}

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

// GetSessionsWithVersionRange is a helper method to define mock.On call
//   - prefix string
//   - r semver.Range
func (_e *MockSession_Expecter) GetSessionsWithVersionRange(prefix interface{}, r interface{}) *MockSession_GetSessionsWithVersionRange_Call {
	return &MockSession_GetSessionsWithVersionRange_Call{Call: _e.mock.On("GetSessionsWithVersionRange", prefix, r)}
}

func (_c *MockSession_GetSessionsWithVersionRange_Call) Run(run func(prefix string, r semver.Range)) *MockSession_GetSessionsWithVersionRange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(semver.Range))
	})
	return _c
}

func (_c *MockSession_GetSessionsWithVersionRange_Call) Return(_a0 map[string]*Session, _a1 int64, _a2 error) *MockSession_GetSessionsWithVersionRange_Call {
	_c.Call.Return(_a0, _a1, _a2)
	return _c
}

func (_c *MockSession_GetSessionsWithVersionRange_Call) RunAndReturn(run func(string, semver.Range) (map[string]*Session, int64, error)) *MockSession_GetSessionsWithVersionRange_Call {
	_c.Call.Return(run)
	return _c
}

// GoingStop provides a mock function with given fields:
func (_m *MockSession) GoingStop() error {
	ret := _m.Called()

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// GoingStop is a helper method to define mock.On call
func (_e *MockSession_Expecter) GoingStop() *MockSession_GoingStop_Call {
	return &MockSession_GoingStop_Call{Call: _e.mock.On("GoingStop")}
}

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

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

func (_c *MockSession_GoingStop_Call) RunAndReturn(run func() error) *MockSession_GoingStop_Call {
	_c.Call.Return(run)
	return _c
}

// Init provides a mock function with given fields: serverName, address, exclusive, triggerKill
func (_m *MockSession) Init(serverName string, address string, exclusive bool, triggerKill bool) {
	_m.Called(serverName, address, exclusive, triggerKill)
}

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

// Init is a helper method to define mock.On call
//   - serverName string
//   - address string
//   - exclusive bool
//   - triggerKill bool
func (_e *MockSession_Expecter) Init(serverName interface{}, address interface{}, exclusive interface{}, triggerKill interface{}) *MockSession_Init_Call {
	return &MockSession_Init_Call{Call: _e.mock.On("Init", serverName, address, exclusive, triggerKill)}
}

func (_c *MockSession_Init_Call) Run(run func(serverName string, address string, exclusive bool, triggerKill bool)) *MockSession_Init_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(bool), args[3].(bool))
	})
	return _c
}

func (_c *MockSession_Init_Call) Return() *MockSession_Init_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_Init_Call) RunAndReturn(run func(string, string, bool, bool)) *MockSession_Init_Call {
	_c.Call.Return(run)
	return _c
}

// IsTriggerKill provides a mock function with given fields:
func (_m *MockSession) IsTriggerKill() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// IsTriggerKill is a helper method to define mock.On call
func (_e *MockSession_Expecter) IsTriggerKill() *MockSession_IsTriggerKill_Call {
	return &MockSession_IsTriggerKill_Call{Call: _e.mock.On("IsTriggerKill")}
}

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

func (_c *MockSession_IsTriggerKill_Call) Return(_a0 bool) *MockSession_IsTriggerKill_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSession_IsTriggerKill_Call) RunAndReturn(run func() bool) *MockSession_IsTriggerKill_Call {
	_c.Call.Return(run)
	return _c
}

// LivenessCheck provides a mock function with given fields: ctx, callback
func (_m *MockSession) LivenessCheck(ctx context.Context, callback func()) {
	_m.Called(ctx, callback)
}

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

// LivenessCheck is a helper method to define mock.On call
//   - ctx context.Context
//   - callback func()
func (_e *MockSession_Expecter) LivenessCheck(ctx interface{}, callback interface{}) *MockSession_LivenessCheck_Call {
	return &MockSession_LivenessCheck_Call{Call: _e.mock.On("LivenessCheck", ctx, callback)}
}

func (_c *MockSession_LivenessCheck_Call) Run(run func(ctx context.Context, callback func())) *MockSession_LivenessCheck_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(func()))
	})
	return _c
}

func (_c *MockSession_LivenessCheck_Call) Return() *MockSession_LivenessCheck_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_LivenessCheck_Call) RunAndReturn(run func(context.Context, func())) *MockSession_LivenessCheck_Call {
	_c.Call.Return(run)
	return _c
}

// MarshalJSON provides a mock function with given fields:
func (_m *MockSession) MarshalJSON() ([]byte, error) {
	ret := _m.Called()

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

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

	return r0, r1
}

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

// MarshalJSON is a helper method to define mock.On call
func (_e *MockSession_Expecter) MarshalJSON() *MockSession_MarshalJSON_Call {
	return &MockSession_MarshalJSON_Call{Call: _e.mock.On("MarshalJSON")}
}

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

func (_c *MockSession_MarshalJSON_Call) Return(_a0 []byte, _a1 error) *MockSession_MarshalJSON_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSession_MarshalJSON_Call) RunAndReturn(run func() ([]byte, error)) *MockSession_MarshalJSON_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessActiveStandBy provides a mock function with given fields: activateFunc
func (_m *MockSession) ProcessActiveStandBy(activateFunc func() error) error {
	ret := _m.Called(activateFunc)

	var r0 error
	if rf, ok := ret.Get(0).(func(func() error) error); ok {
		r0 = rf(activateFunc)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// ProcessActiveStandBy is a helper method to define mock.On call
//   - activateFunc func() error
func (_e *MockSession_Expecter) ProcessActiveStandBy(activateFunc interface{}) *MockSession_ProcessActiveStandBy_Call {
	return &MockSession_ProcessActiveStandBy_Call{Call: _e.mock.On("ProcessActiveStandBy", activateFunc)}
}

func (_c *MockSession_ProcessActiveStandBy_Call) Run(run func(activateFunc func() error)) *MockSession_ProcessActiveStandBy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func() error))
	})
	return _c
}

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

func (_c *MockSession_ProcessActiveStandBy_Call) RunAndReturn(run func(func() error) error) *MockSession_ProcessActiveStandBy_Call {
	_c.Call.Return(run)
	return _c
}

// Register provides a mock function with given fields:
func (_m *MockSession) Register() {
	_m.Called()
}

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

// Register is a helper method to define mock.On call
func (_e *MockSession_Expecter) Register() *MockSession_Register_Call {
	return &MockSession_Register_Call{Call: _e.mock.On("Register")}
}

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

func (_c *MockSession_Register_Call) Return() *MockSession_Register_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_Register_Call) RunAndReturn(run func()) *MockSession_Register_Call {
	_c.Call.Return(run)
	return _c
}

// Registered provides a mock function with given fields:
func (_m *MockSession) Registered() bool {
	ret := _m.Called()

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

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

// Registered is a helper method to define mock.On call
func (_e *MockSession_Expecter) Registered() *MockSession_Registered_Call {
	return &MockSession_Registered_Call{Call: _e.mock.On("Registered")}
}

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

func (_c *MockSession_Registered_Call) Return(_a0 bool) *MockSession_Registered_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSession_Registered_Call) RunAndReturn(run func() bool) *MockSession_Registered_Call {
	_c.Call.Return(run)
	return _c
}

// Revoke provides a mock function with given fields: timeout
func (_m *MockSession) Revoke(timeout time.Duration) {
	_m.Called(timeout)
}

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

// Revoke is a helper method to define mock.On call
//   - timeout time.Duration
func (_e *MockSession_Expecter) Revoke(timeout interface{}) *MockSession_Revoke_Call {
	return &MockSession_Revoke_Call{Call: _e.mock.On("Revoke", timeout)}
}

func (_c *MockSession_Revoke_Call) Run(run func(timeout time.Duration)) *MockSession_Revoke_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(time.Duration))
	})
	return _c
}

func (_c *MockSession_Revoke_Call) Return() *MockSession_Revoke_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_Revoke_Call) RunAndReturn(run func(time.Duration)) *MockSession_Revoke_Call {
	_c.Call.Return(run)
	return _c
}

// SetDisconnected provides a mock function with given fields: b
func (_m *MockSession) SetDisconnected(b bool) {
	_m.Called(b)
}

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

// SetDisconnected is a helper method to define mock.On call
//   - b bool
func (_e *MockSession_Expecter) SetDisconnected(b interface{}) *MockSession_SetDisconnected_Call {
	return &MockSession_SetDisconnected_Call{Call: _e.mock.On("SetDisconnected", b)}
}

func (_c *MockSession_SetDisconnected_Call) Run(run func(b bool)) *MockSession_SetDisconnected_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *MockSession_SetDisconnected_Call) Return() *MockSession_SetDisconnected_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_SetDisconnected_Call) RunAndReturn(run func(bool)) *MockSession_SetDisconnected_Call {
	_c.Call.Return(run)
	return _c
}

// SetEnableActiveStandBy provides a mock function with given fields: enable
func (_m *MockSession) SetEnableActiveStandBy(enable bool) {
	_m.Called(enable)
}

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

// SetEnableActiveStandBy is a helper method to define mock.On call
//   - enable bool
func (_e *MockSession_Expecter) SetEnableActiveStandBy(enable interface{}) *MockSession_SetEnableActiveStandBy_Call {
	return &MockSession_SetEnableActiveStandBy_Call{Call: _e.mock.On("SetEnableActiveStandBy", enable)}
}

func (_c *MockSession_SetEnableActiveStandBy_Call) Run(run func(enable bool)) *MockSession_SetEnableActiveStandBy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *MockSession_SetEnableActiveStandBy_Call) Return() *MockSession_SetEnableActiveStandBy_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_SetEnableActiveStandBy_Call) RunAndReturn(run func(bool)) *MockSession_SetEnableActiveStandBy_Call {
	_c.Call.Return(run)
	return _c
}

// Stop provides a mock function with given fields:
func (_m *MockSession) Stop() {
	_m.Called()
}

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

// Stop is a helper method to define mock.On call
func (_e *MockSession_Expecter) Stop() *MockSession_Stop_Call {
	return &MockSession_Stop_Call{Call: _e.mock.On("Stop")}
}

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

func (_c *MockSession_Stop_Call) Return() *MockSession_Stop_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_Stop_Call) RunAndReturn(run func()) *MockSession_Stop_Call {
	_c.Call.Return(run)
	return _c
}

// String provides a mock function with given fields:
func (_m *MockSession) String() string {
	ret := _m.Called()

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

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

// String is a helper method to define mock.On call
func (_e *MockSession_Expecter) String() *MockSession_String_Call {
	return &MockSession_String_Call{Call: _e.mock.On("String")}
}

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

func (_c *MockSession_String_Call) Return(_a0 string) *MockSession_String_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSession_String_Call) RunAndReturn(run func() string) *MockSession_String_Call {
	_c.Call.Return(run)
	return _c
}

// UnmarshalJSON provides a mock function with given fields: data
func (_m *MockSession) UnmarshalJSON(data []byte) error {
	ret := _m.Called(data)

	var r0 error
	if rf, ok := ret.Get(0).(func([]byte) error); ok {
		r0 = rf(data)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// UnmarshalJSON is a helper method to define mock.On call
//   - data []byte
func (_e *MockSession_Expecter) UnmarshalJSON(data interface{}) *MockSession_UnmarshalJSON_Call {
	return &MockSession_UnmarshalJSON_Call{Call: _e.mock.On("UnmarshalJSON", data)}
}

func (_c *MockSession_UnmarshalJSON_Call) Run(run func(data []byte)) *MockSession_UnmarshalJSON_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]byte))
	})
	return _c
}

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

func (_c *MockSession_UnmarshalJSON_Call) RunAndReturn(run func([]byte) error) *MockSession_UnmarshalJSON_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRegistered provides a mock function with given fields: b
func (_m *MockSession) UpdateRegistered(b bool) {
	_m.Called(b)
}

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

// UpdateRegistered is a helper method to define mock.On call
//   - b bool
func (_e *MockSession_Expecter) UpdateRegistered(b interface{}) *MockSession_UpdateRegistered_Call {
	return &MockSession_UpdateRegistered_Call{Call: _e.mock.On("UpdateRegistered", b)}
}

func (_c *MockSession_UpdateRegistered_Call) Run(run func(b bool)) *MockSession_UpdateRegistered_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(bool))
	})
	return _c
}

func (_c *MockSession_UpdateRegistered_Call) Return() *MockSession_UpdateRegistered_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockSession_UpdateRegistered_Call) RunAndReturn(run func(bool)) *MockSession_UpdateRegistered_Call {
	_c.Call.Return(run)
	return _c
}

// WatchServices provides a mock function with given fields: prefix, revision, rewatch
func (_m *MockSession) WatchServices(prefix string, revision int64, rewatch Rewatch) <-chan *SessionEvent {
	ret := _m.Called(prefix, revision, rewatch)

	var r0 <-chan *SessionEvent
	if rf, ok := ret.Get(0).(func(string, int64, Rewatch) <-chan *SessionEvent); ok {
		r0 = rf(prefix, revision, rewatch)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan *SessionEvent)
		}
	}

	return r0
}

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

// WatchServices is a helper method to define mock.On call
//   - prefix string
//   - revision int64
//   - rewatch Rewatch
func (_e *MockSession_Expecter) WatchServices(prefix interface{}, revision interface{}, rewatch interface{}) *MockSession_WatchServices_Call {
	return &MockSession_WatchServices_Call{Call: _e.mock.On("WatchServices", prefix, revision, rewatch)}
}

func (_c *MockSession_WatchServices_Call) Run(run func(prefix string, revision int64, rewatch Rewatch)) *MockSession_WatchServices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(int64), args[2].(Rewatch))
	})
	return _c
}

func (_c *MockSession_WatchServices_Call) Return(eventChannel <-chan *SessionEvent) *MockSession_WatchServices_Call {
	_c.Call.Return(eventChannel)
	return _c
}

func (_c *MockSession_WatchServices_Call) RunAndReturn(run func(string, int64, Rewatch) <-chan *SessionEvent) *MockSession_WatchServices_Call {
	_c.Call.Return(run)
	return _c
}

// WatchServicesWithVersionRange provides a mock function with given fields: prefix, r, revision, rewatch
func (_m *MockSession) WatchServicesWithVersionRange(prefix string, r semver.Range, revision int64, rewatch Rewatch) <-chan *SessionEvent {
	ret := _m.Called(prefix, r, revision, rewatch)

	var r0 <-chan *SessionEvent
	if rf, ok := ret.Get(0).(func(string, semver.Range, int64, Rewatch) <-chan *SessionEvent); ok {
		r0 = rf(prefix, r, revision, rewatch)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan *SessionEvent)
		}
	}

	return r0
}

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

// WatchServicesWithVersionRange is a helper method to define mock.On call
//   - prefix string
//   - r semver.Range
//   - revision int64
//   - rewatch Rewatch
func (_e *MockSession_Expecter) WatchServicesWithVersionRange(prefix interface{}, r interface{}, revision interface{}, rewatch interface{}) *MockSession_WatchServicesWithVersionRange_Call {
	return &MockSession_WatchServicesWithVersionRange_Call{Call: _e.mock.On("WatchServicesWithVersionRange", prefix, r, revision, rewatch)}
}

func (_c *MockSession_WatchServicesWithVersionRange_Call) Run(run func(prefix string, r semver.Range, revision int64, rewatch Rewatch)) *MockSession_WatchServicesWithVersionRange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(semver.Range), args[2].(int64), args[3].(Rewatch))
	})
	return _c
}

func (_c *MockSession_WatchServicesWithVersionRange_Call) Return(eventChannel <-chan *SessionEvent) *MockSession_WatchServicesWithVersionRange_Call {
	_c.Call.Return(eventChannel)
	return _c
}

func (_c *MockSession_WatchServicesWithVersionRange_Call) RunAndReturn(run func(string, semver.Range, int64, Rewatch) <-chan *SessionEvent) *MockSession_WatchServicesWithVersionRange_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSession creates a new instance of MockSession. 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 NewMockSession(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSession {
	mock := &MockSession{}
	mock.Mock.Test(t)

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

	return mock
}
