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

package mocks

import (
	"time"

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

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

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

	return mock
}

// MockConfigurer is an autogenerated mock type for the Configurer type
type MockConfigurer struct {
	mock.Mock
}

type MockConfigurer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConfigurer) EXPECT() *MockConfigurer_Expecter {
	return &MockConfigurer_Expecter{mock: &_m.Mock}
}

// ControllerAccessRequestTTL provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) ControllerAccessRequestTTL() time.Duration {
	ret := _mock.Called()

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

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

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

// ControllerAccessRequestTTL is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) ControllerAccessRequestTTL() *MockConfigurer_ControllerAccessRequestTTL_Call {
	return &MockConfigurer_ControllerAccessRequestTTL_Call{Call: _e.mock.On("ControllerAccessRequestTTL")}
}

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

func (_c *MockConfigurer_ControllerAccessRequestTTL_Call) Return(duration time.Duration) *MockConfigurer_ControllerAccessRequestTTL_Call {
	_c.Call.Return(duration)
	return _c
}

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

// ControllerEnableHTTP2 provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) ControllerEnableHTTP2() bool {
	ret := _mock.Called()

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

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

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

// ControllerEnableHTTP2 is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) ControllerEnableHTTP2() *MockConfigurer_ControllerEnableHTTP2_Call {
	return &MockConfigurer_ControllerEnableHTTP2_Call{Call: _e.mock.On("ControllerEnableHTTP2")}
}

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

func (_c *MockConfigurer_ControllerEnableHTTP2_Call) Return(b bool) *MockConfigurer_ControllerEnableHTTP2_Call {
	_c.Call.Return(b)
	return _c
}

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

// ControllerHealthProbeAddr provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) ControllerHealthProbeAddr() string {
	ret := _mock.Called()

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

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

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

// ControllerHealthProbeAddr is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) ControllerHealthProbeAddr() *MockConfigurer_ControllerHealthProbeAddr_Call {
	return &MockConfigurer_ControllerHealthProbeAddr_Call{Call: _e.mock.On("ControllerHealthProbeAddr")}
}

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

func (_c *MockConfigurer_ControllerHealthProbeAddr_Call) Return(s string) *MockConfigurer_ControllerHealthProbeAddr_Call {
	_c.Call.Return(s)
	return _c
}

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

// ControllerPort provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) ControllerPort() int {
	ret := _mock.Called()

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

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

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

// ControllerPort is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) ControllerPort() *MockConfigurer_ControllerPort_Call {
	return &MockConfigurer_ControllerPort_Call{Call: _e.mock.On("ControllerPort")}
}

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

func (_c *MockConfigurer_ControllerPort_Call) Return(n int) *MockConfigurer_ControllerPort_Call {
	_c.Call.Return(n)
	return _c
}

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

// ControllerRequestTimeout provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) ControllerRequestTimeout() time.Duration {
	ret := _mock.Called()

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

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

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

// ControllerRequestTimeout is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) ControllerRequestTimeout() *MockConfigurer_ControllerRequestTimeout_Call {
	return &MockConfigurer_ControllerRequestTimeout_Call{Call: _e.mock.On("ControllerRequestTimeout")}
}

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

func (_c *MockConfigurer_ControllerRequestTimeout_Call) Return(duration time.Duration) *MockConfigurer_ControllerRequestTimeout_Call {
	_c.Call.Return(duration)
	return _c
}

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

// ControllerRequeueInterval provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) ControllerRequeueInterval() time.Duration {
	ret := _mock.Called()

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

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

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

// ControllerRequeueInterval is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) ControllerRequeueInterval() *MockConfigurer_ControllerRequeueInterval_Call {
	return &MockConfigurer_ControllerRequeueInterval_Call{Call: _e.mock.On("ControllerRequeueInterval")}
}

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

func (_c *MockConfigurer_ControllerRequeueInterval_Call) Return(duration time.Duration) *MockConfigurer_ControllerRequeueInterval_Call {
	_c.Call.Return(duration)
	return _c
}

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

// EnableLeaderElection provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) EnableLeaderElection() bool {
	ret := _mock.Called()

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

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

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

// EnableLeaderElection is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) EnableLeaderElection() *MockConfigurer_EnableLeaderElection_Call {
	return &MockConfigurer_EnableLeaderElection_Call{Call: _e.mock.On("EnableLeaderElection")}
}

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

func (_c *MockConfigurer_EnableLeaderElection_Call) Return(b bool) *MockConfigurer_EnableLeaderElection_Call {
	_c.Call.Return(b)
	return _c
}

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

// LogFormat provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) LogFormat() string {
	ret := _mock.Called()

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

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

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

// LogFormat is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) LogFormat() *MockConfigurer_LogFormat_Call {
	return &MockConfigurer_LogFormat_Call{Call: _e.mock.On("LogFormat")}
}

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

func (_c *MockConfigurer_LogFormat_Call) Return(s string) *MockConfigurer_LogFormat_Call {
	_c.Call.Return(s)
	return _c
}

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

// LogLevel provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) LogLevel() string {
	ret := _mock.Called()

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

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

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

// LogLevel is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) LogLevel() *MockConfigurer_LogLevel_Call {
	return &MockConfigurer_LogLevel_Call{Call: _e.mock.On("LogLevel")}
}

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

func (_c *MockConfigurer_LogLevel_Call) Return(s string) *MockConfigurer_LogLevel_Call {
	_c.Call.Return(s)
	return _c
}

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

// MetricsAddress provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) MetricsAddress() string {
	ret := _mock.Called()

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

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

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

// MetricsAddress is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) MetricsAddress() *MockConfigurer_MetricsAddress_Call {
	return &MockConfigurer_MetricsAddress_Call{Call: _e.mock.On("MetricsAddress")}
}

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

func (_c *MockConfigurer_MetricsAddress_Call) Return(s string) *MockConfigurer_MetricsAddress_Call {
	_c.Call.Return(s)
	return _c
}

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

// MetricsSecure provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) MetricsSecure() bool {
	ret := _mock.Called()

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

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

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

// MetricsSecure is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) MetricsSecure() *MockConfigurer_MetricsSecure_Call {
	return &MockConfigurer_MetricsSecure_Call{Call: _e.mock.On("MetricsSecure")}
}

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

func (_c *MockConfigurer_MetricsSecure_Call) Return(b bool) *MockConfigurer_MetricsSecure_Call {
	_c.Call.Return(b)
	return _c
}

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

// PluginPath provides a mock function for the type MockConfigurer
func (_mock *MockConfigurer) PluginPath() string {
	ret := _mock.Called()

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

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

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

// PluginPath is a helper method to define mock.On call
func (_e *MockConfigurer_Expecter) PluginPath() *MockConfigurer_PluginPath_Call {
	return &MockConfigurer_PluginPath_Call{Call: _e.mock.On("PluginPath")}
}

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

func (_c *MockConfigurer_PluginPath_Call) Return(s string) *MockConfigurer_PluginPath_Call {
	_c.Call.Return(s)
	return _c
}

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