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

package mocks

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

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

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

	return mock
}

// MockXDGPaths is an autogenerated mock type for the XDGPaths type
type MockXDGPaths struct {
	mock.Mock
}

type MockXDGPaths_Expecter struct {
	mock *mock.Mock
}

func (_m *MockXDGPaths) EXPECT() *MockXDGPaths_Expecter {
	return &MockXDGPaths_Expecter{mock: &_m.Mock}
}

// CacheDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) CacheDir() (string, error) {
	ret := _mock.Called()

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

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

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

// CacheDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) CacheDir() *MockXDGPaths_CacheDir_Call {
	return &MockXDGPaths_CacheDir_Call{Call: _e.mock.On("CacheDir")}
}

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

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

func (_c *MockXDGPaths_CacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_CacheDir_Call {
	_c.Call.Return(run)
	return _c
}

// ConfigDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) ConfigDir() (string, error) {
	ret := _mock.Called()

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

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

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

// ConfigDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) ConfigDir() *MockXDGPaths_ConfigDir_Call {
	return &MockXDGPaths_ConfigDir_Call{Call: _e.mock.On("ConfigDir")}
}

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

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

func (_c *MockXDGPaths_ConfigDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ConfigDir_Call {
	_c.Call.Return(run)
	return _c
}

// DataDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) DataDir() (string, error) {
	ret := _mock.Called()

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

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

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

// DataDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) DataDir() *MockXDGPaths_DataDir_Call {
	return &MockXDGPaths_DataDir_Call{Call: _e.mock.On("DataDir")}
}

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

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

func (_c *MockXDGPaths_DataDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DataDir_Call {
	_c.Call.Return(run)
	return _c
}

// DownloadDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) DownloadDir() (string, error) {
	ret := _mock.Called()

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

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

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

// DownloadDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) DownloadDir() *MockXDGPaths_DownloadDir_Call {
	return &MockXDGPaths_DownloadDir_Call{Call: _e.mock.On("DownloadDir")}
}

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

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

func (_c *MockXDGPaths_DownloadDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_DownloadDir_Call {
	_c.Call.Return(run)
	return _c
}

// FilterCacheDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) FilterCacheDir() (string, error) {
	ret := _mock.Called()

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

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

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

// FilterCacheDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) FilterCacheDir() *MockXDGPaths_FilterCacheDir_Call {
	return &MockXDGPaths_FilterCacheDir_Call{Call: _e.mock.On("FilterCacheDir")}
}

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

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

func (_c *MockXDGPaths_FilterCacheDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterCacheDir_Call {
	_c.Call.Return(run)
	return _c
}

// FilterJSONDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) FilterJSONDir() (string, error) {
	ret := _mock.Called()

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

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

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

// FilterJSONDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) FilterJSONDir() *MockXDGPaths_FilterJSONDir_Call {
	return &MockXDGPaths_FilterJSONDir_Call{Call: _e.mock.On("FilterJSONDir")}
}

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

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

func (_c *MockXDGPaths_FilterJSONDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterJSONDir_Call {
	_c.Call.Return(run)
	return _c
}

// FilterStoreDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) FilterStoreDir() (string, error) {
	ret := _mock.Called()

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

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

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

// FilterStoreDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) FilterStoreDir() *MockXDGPaths_FilterStoreDir_Call {
	return &MockXDGPaths_FilterStoreDir_Call{Call: _e.mock.On("FilterStoreDir")}
}

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

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

func (_c *MockXDGPaths_FilterStoreDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_FilterStoreDir_Call {
	_c.Call.Return(run)
	return _c
}

// ManDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) ManDir() (string, error) {
	ret := _mock.Called()

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

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

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

// ManDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) ManDir() *MockXDGPaths_ManDir_Call {
	return &MockXDGPaths_ManDir_Call{Call: _e.mock.On("ManDir")}
}

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

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

func (_c *MockXDGPaths_ManDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_ManDir_Call {
	_c.Call.Return(run)
	return _c
}

// RuntimeDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) RuntimeDir() (string, error) {
	ret := _mock.Called()

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

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

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

// RuntimeDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) RuntimeDir() *MockXDGPaths_RuntimeDir_Call {
	return &MockXDGPaths_RuntimeDir_Call{Call: _e.mock.On("RuntimeDir")}
}

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

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

func (_c *MockXDGPaths_RuntimeDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_RuntimeDir_Call {
	_c.Call.Return(run)
	return _c
}

// StateDir provides a mock function for the type MockXDGPaths
func (_mock *MockXDGPaths) StateDir() (string, error) {
	ret := _mock.Called()

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

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

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

// StateDir is a helper method to define mock.On call
func (_e *MockXDGPaths_Expecter) StateDir() *MockXDGPaths_StateDir_Call {
	return &MockXDGPaths_StateDir_Call{Call: _e.mock.On("StateDir")}
}

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

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

func (_c *MockXDGPaths_StateDir_Call) RunAndReturn(run func() (string, error)) *MockXDGPaths_StateDir_Call {
	_c.Call.Return(run)
	return _c
}