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

package command

import (
	mock "github.com/stretchr/testify/mock"
)

// NewMockContext creates a new instance of MockContext. 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 NewMockContext(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockContext {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockContext{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockContext is an autogenerated mock type for the Context type
type MockContext struct {
	mock.Mock
}

type MockContext_Expecter struct {
	mock *mock.Mock
}

func (_m *MockContext) EXPECT() *MockContext_Expecter {
	return &MockContext_Expecter{mock: &_m.Mock}
}

// BackSession provides a mock function for the type MockContext
func (_mock *MockContext) BackSession() error {
	ret := _mock.Called()

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

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

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

// BackSession is a helper method to define mock.On call
func (_e *MockContext_Expecter) BackSession() *MockContext_BackSession_Call {
	return &MockContext_BackSession_Call{Call: _e.mock.On("BackSession")}
}

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

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

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

// ClosePane provides a mock function for the type MockContext
func (_mock *MockContext) ClosePane() error {
	ret := _mock.Called()

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

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

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

// ClosePane is a helper method to define mock.On call
func (_e *MockContext_Expecter) ClosePane() *MockContext_ClosePane_Call {
	return &MockContext_ClosePane_Call{Call: _e.mock.On("ClosePane")}
}

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

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

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

// CloseTab provides a mock function for the type MockContext
func (_mock *MockContext) CloseTab() error {
	ret := _mock.Called()

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

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

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

// CloseTab is a helper method to define mock.On call
func (_e *MockContext_Expecter) CloseTab() *MockContext_CloseTab_Call {
	return &MockContext_CloseTab_Call{Call: _e.mock.On("CloseTab")}
}

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

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

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

// ConsumeOrExpelPaneLeft provides a mock function for the type MockContext
func (_mock *MockContext) ConsumeOrExpelPaneLeft() error {
	ret := _mock.Called()

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

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

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

// ConsumeOrExpelPaneLeft is a helper method to define mock.On call
func (_e *MockContext_Expecter) ConsumeOrExpelPaneLeft() *MockContext_ConsumeOrExpelPaneLeft_Call {
	return &MockContext_ConsumeOrExpelPaneLeft_Call{Call: _e.mock.On("ConsumeOrExpelPaneLeft")}
}

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

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

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

// ConsumeOrExpelPaneRight provides a mock function for the type MockContext
func (_mock *MockContext) ConsumeOrExpelPaneRight() error {
	ret := _mock.Called()

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

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

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

// ConsumeOrExpelPaneRight is a helper method to define mock.On call
func (_e *MockContext_Expecter) ConsumeOrExpelPaneRight() *MockContext_ConsumeOrExpelPaneRight_Call {
	return &MockContext_ConsumeOrExpelPaneRight_Call{Call: _e.mock.On("ConsumeOrExpelPaneRight")}
}

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

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

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

// CreateEphemeralSession provides a mock function for the type MockContext
func (_mock *MockContext) CreateEphemeralSession() error {
	ret := _mock.Called()

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

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

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

// CreateEphemeralSession is a helper method to define mock.On call
func (_e *MockContext_Expecter) CreateEphemeralSession() *MockContext_CreateEphemeralSession_Call {
	return &MockContext_CreateEphemeralSession_Call{Call: _e.mock.On("CreateEphemeralSession")}
}

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

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

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

// CreateSession provides a mock function for the type MockContext
func (_mock *MockContext) CreateSession() error {
	ret := _mock.Called()

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

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

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

// CreateSession is a helper method to define mock.On call
func (_e *MockContext_Expecter) CreateSession() *MockContext_CreateSession_Call {
	return &MockContext_CreateSession_Call{Call: _e.mock.On("CreateSession")}
}

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

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

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

// CreateSessionNamed provides a mock function for the type MockContext
func (_mock *MockContext) CreateSessionNamed(name string) error {
	ret := _mock.Called(name)

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

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

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

// CreateSessionNamed is a helper method to define mock.On call
//   - name string
func (_e *MockContext_Expecter) CreateSessionNamed(name any) *MockContext_CreateSessionNamed_Call {
	return &MockContext_CreateSessionNamed_Call{Call: _e.mock.On("CreateSessionNamed", name)}
}

func (_c *MockContext_CreateSessionNamed_Call) Run(run func(name string)) *MockContext_CreateSessionNamed_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockContext_CreateSessionNamed_Call) RunAndReturn(run func(name string) error) *MockContext_CreateSessionNamed_Call {
	_c.Call.Return(run)
	return _c
}

// CreateTab provides a mock function for the type MockContext
func (_mock *MockContext) CreateTab() error {
	ret := _mock.Called()

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

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

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

// CreateTab is a helper method to define mock.On call
func (_e *MockContext_Expecter) CreateTab() *MockContext_CreateTab_Call {
	return &MockContext_CreateTab_Call{Call: _e.mock.On("CreateTab")}
}

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

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

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

// Detach provides a mock function for the type MockContext
func (_mock *MockContext) Detach() error {
	ret := _mock.Called()

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

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

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

// Detach is a helper method to define mock.On call
func (_e *MockContext_Expecter) Detach() *MockContext_Detach_Call {
	return &MockContext_Detach_Call{Call: _e.mock.On("Detach")}
}

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

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

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

// EnterResizeMode provides a mock function for the type MockContext
func (_mock *MockContext) EnterResizeMode() error {
	ret := _mock.Called()

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

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

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

// EnterResizeMode is a helper method to define mock.On call
func (_e *MockContext_Expecter) EnterResizeMode() *MockContext_EnterResizeMode_Call {
	return &MockContext_EnterResizeMode_Call{Call: _e.mock.On("EnterResizeMode")}
}

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

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

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

// EnterVisualMode provides a mock function for the type MockContext
func (_mock *MockContext) EnterVisualMode() error {
	ret := _mock.Called()

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

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

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

// EnterVisualMode is a helper method to define mock.On call
func (_e *MockContext_Expecter) EnterVisualMode() *MockContext_EnterVisualMode_Call {
	return &MockContext_EnterVisualMode_Call{Call: _e.mock.On("EnterVisualMode")}
}

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

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

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

// EqualizePanes provides a mock function for the type MockContext
func (_mock *MockContext) EqualizePanes() error {
	ret := _mock.Called()

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

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

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

// EqualizePanes is a helper method to define mock.On call
func (_e *MockContext_Expecter) EqualizePanes() *MockContext_EqualizePanes_Call {
	return &MockContext_EqualizePanes_Call{Call: _e.mock.On("EqualizePanes")}
}

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

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

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

// FocusPaneDown provides a mock function for the type MockContext
func (_mock *MockContext) FocusPaneDown() error {
	ret := _mock.Called()

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

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

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

// FocusPaneDown is a helper method to define mock.On call
func (_e *MockContext_Expecter) FocusPaneDown() *MockContext_FocusPaneDown_Call {
	return &MockContext_FocusPaneDown_Call{Call: _e.mock.On("FocusPaneDown")}
}

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

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

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

// FocusPaneLeft provides a mock function for the type MockContext
func (_mock *MockContext) FocusPaneLeft() error {
	ret := _mock.Called()

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

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

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

// FocusPaneLeft is a helper method to define mock.On call
func (_e *MockContext_Expecter) FocusPaneLeft() *MockContext_FocusPaneLeft_Call {
	return &MockContext_FocusPaneLeft_Call{Call: _e.mock.On("FocusPaneLeft")}
}

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

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

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

// FocusPaneRight provides a mock function for the type MockContext
func (_mock *MockContext) FocusPaneRight() error {
	ret := _mock.Called()

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

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

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

// FocusPaneRight is a helper method to define mock.On call
func (_e *MockContext_Expecter) FocusPaneRight() *MockContext_FocusPaneRight_Call {
	return &MockContext_FocusPaneRight_Call{Call: _e.mock.On("FocusPaneRight")}
}

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

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

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

// FocusPaneUp provides a mock function for the type MockContext
func (_mock *MockContext) FocusPaneUp() error {
	ret := _mock.Called()

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

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

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

// FocusPaneUp is a helper method to define mock.On call
func (_e *MockContext_Expecter) FocusPaneUp() *MockContext_FocusPaneUp_Call {
	return &MockContext_FocusPaneUp_Call{Call: _e.mock.On("FocusPaneUp")}
}

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

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

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

// GrowPaneHeight provides a mock function for the type MockContext
func (_mock *MockContext) GrowPaneHeight() error {
	ret := _mock.Called()

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

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

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

// GrowPaneHeight is a helper method to define mock.On call
func (_e *MockContext_Expecter) GrowPaneHeight() *MockContext_GrowPaneHeight_Call {
	return &MockContext_GrowPaneHeight_Call{Call: _e.mock.On("GrowPaneHeight")}
}

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

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

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

// GrowPaneWidth provides a mock function for the type MockContext
func (_mock *MockContext) GrowPaneWidth() error {
	ret := _mock.Called()

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

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

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

// GrowPaneWidth is a helper method to define mock.On call
func (_e *MockContext_Expecter) GrowPaneWidth() *MockContext_GrowPaneWidth_Call {
	return &MockContext_GrowPaneWidth_Call{Call: _e.mock.On("GrowPaneWidth")}
}

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

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

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

// JumpRecentSession provides a mock function for the type MockContext
func (_mock *MockContext) JumpRecentSession(rank int) error {
	ret := _mock.Called(rank)

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

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

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

// JumpRecentSession is a helper method to define mock.On call
//   - rank int
func (_e *MockContext_Expecter) JumpRecentSession(rank any) *MockContext_JumpRecentSession_Call {
	return &MockContext_JumpRecentSession_Call{Call: _e.mock.On("JumpRecentSession", rank)}
}

func (_c *MockContext_JumpRecentSession_Call) Run(run func(rank int)) *MockContext_JumpRecentSession_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockContext_JumpRecentSession_Call) RunAndReturn(run func(rank int) error) *MockContext_JumpRecentSession_Call {
	_c.Call.Return(run)
	return _c
}

// NextTab provides a mock function for the type MockContext
func (_mock *MockContext) NextTab() error {
	ret := _mock.Called()

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

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

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

// NextTab is a helper method to define mock.On call
func (_e *MockContext_Expecter) NextTab() *MockContext_NextTab_Call {
	return &MockContext_NextTab_Call{Call: _e.mock.On("NextTab")}
}

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

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

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

// OpenMovePanePicker provides a mock function for the type MockContext
func (_mock *MockContext) OpenMovePanePicker() error {
	ret := _mock.Called()

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

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

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

// OpenMovePanePicker is a helper method to define mock.On call
func (_e *MockContext_Expecter) OpenMovePanePicker() *MockContext_OpenMovePanePicker_Call {
	return &MockContext_OpenMovePanePicker_Call{Call: _e.mock.On("OpenMovePanePicker")}
}

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

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

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

// OpenMoveTabPicker provides a mock function for the type MockContext
func (_mock *MockContext) OpenMoveTabPicker() error {
	ret := _mock.Called()

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

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

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

// OpenMoveTabPicker is a helper method to define mock.On call
func (_e *MockContext_Expecter) OpenMoveTabPicker() *MockContext_OpenMoveTabPicker_Call {
	return &MockContext_OpenMoveTabPicker_Call{Call: _e.mock.On("OpenMoveTabPicker")}
}

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

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

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

// OpenNotifications provides a mock function for the type MockContext
func (_mock *MockContext) OpenNotifications() error {
	ret := _mock.Called()

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

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

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

// OpenNotifications is a helper method to define mock.On call
func (_e *MockContext_Expecter) OpenNotifications() *MockContext_OpenNotifications_Call {
	return &MockContext_OpenNotifications_Call{Call: _e.mock.On("OpenNotifications")}
}

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

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

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

// OpenSessionPicker provides a mock function for the type MockContext
func (_mock *MockContext) OpenSessionPicker() error {
	ret := _mock.Called()

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

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

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

// OpenSessionPicker is a helper method to define mock.On call
func (_e *MockContext_Expecter) OpenSessionPicker() *MockContext_OpenSessionPicker_Call {
	return &MockContext_OpenSessionPicker_Call{Call: _e.mock.On("OpenSessionPicker")}
}

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

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

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

// PrevTab provides a mock function for the type MockContext
func (_mock *MockContext) PrevTab() error {
	ret := _mock.Called()

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

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

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

// PrevTab is a helper method to define mock.On call
func (_e *MockContext_Expecter) PrevTab() *MockContext_PrevTab_Call {
	return &MockContext_PrevTab_Call{Call: _e.mock.On("PrevTab")}
}

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

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

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

// RenameSession provides a mock function for the type MockContext
func (_mock *MockContext) RenameSession() error {
	ret := _mock.Called()

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

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

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

// RenameSession is a helper method to define mock.On call
func (_e *MockContext_Expecter) RenameSession() *MockContext_RenameSession_Call {
	return &MockContext_RenameSession_Call{Call: _e.mock.On("RenameSession")}
}

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

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

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

// RenameSessionTo provides a mock function for the type MockContext
func (_mock *MockContext) RenameSessionTo(name string) error {
	ret := _mock.Called(name)

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

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

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

// RenameSessionTo is a helper method to define mock.On call
//   - name string
func (_e *MockContext_Expecter) RenameSessionTo(name any) *MockContext_RenameSessionTo_Call {
	return &MockContext_RenameSessionTo_Call{Call: _e.mock.On("RenameSessionTo", name)}
}

func (_c *MockContext_RenameSessionTo_Call) Run(run func(name string)) *MockContext_RenameSessionTo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockContext_RenameSessionTo_Call) RunAndReturn(run func(name string) error) *MockContext_RenameSessionTo_Call {
	_c.Call.Return(run)
	return _c
}

// RenameTab provides a mock function for the type MockContext
func (_mock *MockContext) RenameTab() error {
	ret := _mock.Called()

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

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

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

// RenameTab is a helper method to define mock.On call
func (_e *MockContext_Expecter) RenameTab() *MockContext_RenameTab_Call {
	return &MockContext_RenameTab_Call{Call: _e.mock.On("RenameTab")}
}

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

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

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

// RenameTabTo provides a mock function for the type MockContext
func (_mock *MockContext) RenameTabTo(name string) error {
	ret := _mock.Called(name)

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

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

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

// RenameTabTo is a helper method to define mock.On call
//   - name string
func (_e *MockContext_Expecter) RenameTabTo(name any) *MockContext_RenameTabTo_Call {
	return &MockContext_RenameTabTo_Call{Call: _e.mock.On("RenameTabTo", name)}
}

func (_c *MockContext_RenameTabTo_Call) Run(run func(name string)) *MockContext_RenameTabTo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockContext_RenameTabTo_Call) RunAndReturn(run func(name string) error) *MockContext_RenameTabTo_Call {
	_c.Call.Return(run)
	return _c
}

// ShrinkPaneHeight provides a mock function for the type MockContext
func (_mock *MockContext) ShrinkPaneHeight() error {
	ret := _mock.Called()

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

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

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

// ShrinkPaneHeight is a helper method to define mock.On call
func (_e *MockContext_Expecter) ShrinkPaneHeight() *MockContext_ShrinkPaneHeight_Call {
	return &MockContext_ShrinkPaneHeight_Call{Call: _e.mock.On("ShrinkPaneHeight")}
}

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

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

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

// ShrinkPaneWidth provides a mock function for the type MockContext
func (_mock *MockContext) ShrinkPaneWidth() error {
	ret := _mock.Called()

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

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

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

// ShrinkPaneWidth is a helper method to define mock.On call
func (_e *MockContext_Expecter) ShrinkPaneWidth() *MockContext_ShrinkPaneWidth_Call {
	return &MockContext_ShrinkPaneWidth_Call{Call: _e.mock.On("ShrinkPaneWidth")}
}

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

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

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

// SplitDown provides a mock function for the type MockContext
func (_mock *MockContext) SplitDown() error {
	ret := _mock.Called()

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

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

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

// SplitDown is a helper method to define mock.On call
func (_e *MockContext_Expecter) SplitDown() *MockContext_SplitDown_Call {
	return &MockContext_SplitDown_Call{Call: _e.mock.On("SplitDown")}
}

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

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

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

// SplitLeft provides a mock function for the type MockContext
func (_mock *MockContext) SplitLeft() error {
	ret := _mock.Called()

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

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

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

// SplitLeft is a helper method to define mock.On call
func (_e *MockContext_Expecter) SplitLeft() *MockContext_SplitLeft_Call {
	return &MockContext_SplitLeft_Call{Call: _e.mock.On("SplitLeft")}
}

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

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

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

// SplitRight provides a mock function for the type MockContext
func (_mock *MockContext) SplitRight() error {
	ret := _mock.Called()

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

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

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

// SplitRight is a helper method to define mock.On call
func (_e *MockContext_Expecter) SplitRight() *MockContext_SplitRight_Call {
	return &MockContext_SplitRight_Call{Call: _e.mock.On("SplitRight")}
}

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

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

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

// SplitUp provides a mock function for the type MockContext
func (_mock *MockContext) SplitUp() error {
	ret := _mock.Called()

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

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

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

// SplitUp is a helper method to define mock.On call
func (_e *MockContext_Expecter) SplitUp() *MockContext_SplitUp_Call {
	return &MockContext_SplitUp_Call{Call: _e.mock.On("SplitUp")}
}

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

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

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

// StackPane provides a mock function for the type MockContext
func (_mock *MockContext) StackPane() error {
	ret := _mock.Called()

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

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

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

// StackPane is a helper method to define mock.On call
func (_e *MockContext_Expecter) StackPane() *MockContext_StackPane_Call {
	return &MockContext_StackPane_Call{Call: _e.mock.On("StackPane")}
}

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

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

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

// ToggleFloatingPane provides a mock function for the type MockContext
func (_mock *MockContext) ToggleFloatingPane() error {
	ret := _mock.Called()

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

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

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

// ToggleFloatingPane is a helper method to define mock.On call
func (_e *MockContext_Expecter) ToggleFloatingPane() *MockContext_ToggleFloatingPane_Call {
	return &MockContext_ToggleFloatingPane_Call{Call: _e.mock.On("ToggleFloatingPane")}
}

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

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

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

// ToggleStack provides a mock function for the type MockContext
func (_mock *MockContext) ToggleStack() error {
	ret := _mock.Called()

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

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

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

// ToggleStack is a helper method to define mock.On call
func (_e *MockContext_Expecter) ToggleStack() *MockContext_ToggleStack_Call {
	return &MockContext_ToggleStack_Call{Call: _e.mock.On("ToggleStack")}
}

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

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

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

// YankLastNotification provides a mock function for the type MockContext
func (_mock *MockContext) YankLastNotification() error {
	ret := _mock.Called()

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

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

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

// YankLastNotification is a helper method to define mock.On call
func (_e *MockContext_Expecter) YankLastNotification() *MockContext_YankLastNotification_Call {
	return &MockContext_YankLastNotification_Call{Call: _e.mock.On("YankLastNotification")}
}

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

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

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