// TEST MOCKERY BOILERPLATE

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

package test

import (
	"encoding/json"
	"io"
	"net/http"
	"unsafe"

	mock "github.com/stretchr/testify/mock"
	http1 "github.com/vektra/mockery/v3/internal/fixtures/12345678/http"
	"github.com/vektra/mockery/v3/internal/fixtures/constraints"
	http0 "github.com/vektra/mockery/v3/internal/fixtures/http"
	"github.com/vektra/mockery/v3/internal/fixtures/redefined_type_b"
)

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

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

	return mock
}

// MockUsesAny is an autogenerated mock type for the UsesAny type
type MockUsesAny struct {
	mock.Mock
}

type MockUsesAny_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUsesAny) EXPECT() *MockUsesAny_Expecter {
	return &MockUsesAny_Expecter{mock: &_m.Mock}
}

// GetReader provides a mock function for the type MockUsesAny
func (_mock *MockUsesAny) GetReader() any {
	ret := _mock.Called()

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

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

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

// GetReader is a helper method to define mock.On call
func (_e *MockUsesAny_Expecter) GetReader() *MockUsesAny_GetReader_Call {
	return &MockUsesAny_GetReader_Call{Call: _e.mock.On("GetReader")}
}

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

func (_c *MockUsesAny_GetReader_Call) Return(v any) *MockUsesAny_GetReader_Call {
	_c.Call.Return(v)
	return _c
}

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

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

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

	return mock
}

// MockFooer is an autogenerated mock type for the Fooer type
type MockFooer struct {
	mock.Mock
}

type MockFooer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFooer) EXPECT() *MockFooer_Expecter {
	return &MockFooer_Expecter{mock: &_m.Mock}
}

// Bar provides a mock function for the type MockFooer
func (_mock *MockFooer) Bar(f func([]int)) {
	_mock.Called(f)
	return
}

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

// Bar is a helper method to define mock.On call
//   - f func([]int)
func (_e *MockFooer_Expecter) Bar(f interface{}) *MockFooer_Bar_Call {
	return &MockFooer_Bar_Call{Call: _e.mock.On("Bar", f)}
}

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

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

func (_c *MockFooer_Bar_Call) RunAndReturn(run func(f func([]int))) *MockFooer_Bar_Call {
	_c.Run(run)
	return _c
}

// Baz provides a mock function for the type MockFooer
func (_mock *MockFooer) Baz(path string) func(x string) string {
	ret := _mock.Called(path)

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

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

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

// Baz is a helper method to define mock.On call
//   - path string
func (_e *MockFooer_Expecter) Baz(path interface{}) *MockFooer_Baz_Call {
	return &MockFooer_Baz_Call{Call: _e.mock.On("Baz", path)}
}

func (_c *MockFooer_Baz_Call) Run(run func(path string)) *MockFooer_Baz_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 *MockFooer_Baz_Call) Return(fn func(x string) string) *MockFooer_Baz_Call {
	_c.Call.Return(fn)
	return _c
}

func (_c *MockFooer_Baz_Call) RunAndReturn(run func(path string) func(x string) string) *MockFooer_Baz_Call {
	_c.Call.Return(run)
	return _c
}

// Foo provides a mock function for the type MockFooer
func (_mock *MockFooer) Foo(f func(x string) string) error {
	ret := _mock.Called(f)

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

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

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

// Foo is a helper method to define mock.On call
//   - f func(x string) string
func (_e *MockFooer_Expecter) Foo(f interface{}) *MockFooer_Foo_Call {
	return &MockFooer_Foo_Call{Call: _e.mock.On("Foo", f)}
}

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

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

func (_c *MockFooer_Foo_Call) RunAndReturn(run func(f func(x string) string) error) *MockFooer_Foo_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockMapFunc is an autogenerated mock type for the MapFunc type
type MockMapFunc struct {
	mock.Mock
}

type MockMapFunc_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMapFunc) EXPECT() *MockMapFunc_Expecter {
	return &MockMapFunc_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockMapFunc
func (_mock *MockMapFunc) Get(m map[string]func(string) string) error {
	ret := _mock.Called(m)

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

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

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

// Get is a helper method to define mock.On call
//   - m map[string]func(string) string
func (_e *MockMapFunc_Expecter) Get(m interface{}) *MockMapFunc_Get_Call {
	return &MockMapFunc_Get_Call{Call: _e.mock.On("Get", m)}
}

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

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

func (_c *MockMapFunc_Get_Call) RunAndReturn(run func(m map[string]func(string) string) error) *MockMapFunc_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockAsyncProducer is an autogenerated mock type for the AsyncProducer type
type MockAsyncProducer struct {
	mock.Mock
}

type MockAsyncProducer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockAsyncProducer) EXPECT() *MockAsyncProducer_Expecter {
	return &MockAsyncProducer_Expecter{mock: &_m.Mock}
}

// Input provides a mock function for the type MockAsyncProducer
func (_mock *MockAsyncProducer) Input() chan<- bool {
	ret := _mock.Called()

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

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

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

// Input is a helper method to define mock.On call
func (_e *MockAsyncProducer_Expecter) Input() *MockAsyncProducer_Input_Call {
	return &MockAsyncProducer_Input_Call{Call: _e.mock.On("Input")}
}

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

func (_c *MockAsyncProducer_Input_Call) Return(boolCh chan<- bool) *MockAsyncProducer_Input_Call {
	_c.Call.Return(boolCh)
	return _c
}

func (_c *MockAsyncProducer_Input_Call) RunAndReturn(run func() chan<- bool) *MockAsyncProducer_Input_Call {
	_c.Call.Return(run)
	return _c
}

// Output provides a mock function for the type MockAsyncProducer
func (_mock *MockAsyncProducer) Output() <-chan bool {
	ret := _mock.Called()

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

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

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

// Output is a helper method to define mock.On call
func (_e *MockAsyncProducer_Expecter) Output() *MockAsyncProducer_Output_Call {
	return &MockAsyncProducer_Output_Call{Call: _e.mock.On("Output")}
}

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

func (_c *MockAsyncProducer_Output_Call) Return(boolCh <-chan bool) *MockAsyncProducer_Output_Call {
	_c.Call.Return(boolCh)
	return _c
}

func (_c *MockAsyncProducer_Output_Call) RunAndReturn(run func() <-chan bool) *MockAsyncProducer_Output_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Whatever is a helper method to define mock.On call
func (_e *MockAsyncProducer_Expecter) Whatever() *MockAsyncProducer_Whatever_Call {
	return &MockAsyncProducer_Whatever_Call{Call: _e.mock.On("Whatever")}
}

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

func (_c *MockAsyncProducer_Whatever_Call) Return(boolCh chan bool) *MockAsyncProducer_Whatever_Call {
	_c.Call.Return(boolCh)
	return _c
}

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

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

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

	return mock
}

// MockConsulLock is an autogenerated mock type for the ConsulLock type
type MockConsulLock struct {
	mock.Mock
}

type MockConsulLock_Expecter struct {
	mock *mock.Mock
}

func (_m *MockConsulLock) EXPECT() *MockConsulLock_Expecter {
	return &MockConsulLock_Expecter{mock: &_m.Mock}
}

// Lock provides a mock function for the type MockConsulLock
func (_mock *MockConsulLock) Lock(valCh <-chan struct{}) (<-chan struct{}, error) {
	ret := _mock.Called(valCh)

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

	var r0 <-chan struct{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(<-chan struct{}) (<-chan struct{}, error)); ok {
		return returnFunc(valCh)
	}
	if returnFunc, ok := ret.Get(0).(func(<-chan struct{}) <-chan struct{}); ok {
		r0 = returnFunc(valCh)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(<-chan struct{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(<-chan struct{}) error); ok {
		r1 = returnFunc(valCh)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// Lock is a helper method to define mock.On call
//   - valCh <-chan struct{}
func (_e *MockConsulLock_Expecter) Lock(valCh interface{}) *MockConsulLock_Lock_Call {
	return &MockConsulLock_Lock_Call{Call: _e.mock.On("Lock", valCh)}
}

func (_c *MockConsulLock_Lock_Call) Run(run func(valCh <-chan struct{})) *MockConsulLock_Lock_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 <-chan struct{}
		if args[0] != nil {
			arg0 = args[0].(<-chan struct{})
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockConsulLock_Lock_Call) Return(valCh1 <-chan struct{}, err error) *MockConsulLock_Lock_Call {
	_c.Call.Return(valCh1, err)
	return _c
}

func (_c *MockConsulLock_Lock_Call) RunAndReturn(run func(valCh <-chan struct{}) (<-chan struct{}, error)) *MockConsulLock_Lock_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// Unlock is a helper method to define mock.On call
func (_e *MockConsulLock_Expecter) Unlock() *MockConsulLock_Unlock_Call {
	return &MockConsulLock_Unlock_Call{Call: _e.mock.On("Unlock")}
}

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

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

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

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

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

	return mock
}

// MockKeyManager is an autogenerated mock type for the KeyManager type
type MockKeyManager struct {
	mock.Mock
}

type MockKeyManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockKeyManager) EXPECT() *MockKeyManager_Expecter {
	return &MockKeyManager_Expecter{mock: &_m.Mock}
}

// GetKey provides a mock function for the type MockKeyManager
func (_mock *MockKeyManager) GetKey(s string, v uint16) ([]byte, *Err) {
	ret := _mock.Called(s, v)

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

	var r0 []byte
	var r1 *Err
	if returnFunc, ok := ret.Get(0).(func(string, uint16) ([]byte, *Err)); ok {
		return returnFunc(s, v)
	}
	if returnFunc, ok := ret.Get(0).(func(string, uint16) []byte); ok {
		r0 = returnFunc(s, v)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, uint16) *Err); ok {
		r1 = returnFunc(s, v)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*Err)
		}
	}
	return r0, r1
}

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

// GetKey is a helper method to define mock.On call
//   - s string
//   - v uint16
func (_e *MockKeyManager_Expecter) GetKey(s interface{}, v interface{}) *MockKeyManager_GetKey_Call {
	return &MockKeyManager_GetKey_Call{Call: _e.mock.On("GetKey", s, v)}
}

func (_c *MockKeyManager_GetKey_Call) Run(run func(s string, v uint16)) *MockKeyManager_GetKey_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 uint16
		if args[1] != nil {
			arg1 = args[1].(uint16)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockKeyManager_GetKey_Call) Return(bytes []byte, err *Err) *MockKeyManager_GetKey_Call {
	_c.Call.Return(bytes, err)
	return _c
}

func (_c *MockKeyManager_GetKey_Call) RunAndReturn(run func(s string, v uint16) ([]byte, *Err)) *MockKeyManager_GetKey_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockBlank is an autogenerated mock type for the Blank type
type MockBlank struct {
	mock.Mock
}

type MockBlank_Expecter struct {
	mock *mock.Mock
}

func (_m *MockBlank) EXPECT() *MockBlank_Expecter {
	return &MockBlank_Expecter{mock: &_m.Mock}
}

// Create provides a mock function for the type MockBlank
func (_mock *MockBlank) Create(x interface{}) error {
	ret := _mock.Called(x)

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

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

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

// Create is a helper method to define mock.On call
//   - x interface{}
func (_e *MockBlank_Expecter) Create(x interface{}) *MockBlank_Create_Call {
	return &MockBlank_Create_Call{Call: _e.mock.On("Create", x)}
}

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

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

func (_c *MockBlank_Create_Call) RunAndReturn(run func(x interface{}) error) *MockBlank_Create_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockExpecterAndRolledVariadic is an autogenerated mock type for the Expecter type
type MockExpecterAndRolledVariadic struct {
	mock.Mock
}

type MockExpecterAndRolledVariadic_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExpecterAndRolledVariadic) EXPECT() *MockExpecterAndRolledVariadic_Expecter {
	return &MockExpecterAndRolledVariadic_Expecter{mock: &_m.Mock}
}

// ManyArgsReturns provides a mock function for the type MockExpecterAndRolledVariadic
func (_mock *MockExpecterAndRolledVariadic) ManyArgsReturns(str string, i int) ([]string, error) {
	ret := _mock.Called(str, i)

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

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok {
		return returnFunc(str, i)
	}
	if returnFunc, ok := ret.Get(0).(func(string, int) []string); ok {
		r0 = returnFunc(str, i)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, int) error); ok {
		r1 = returnFunc(str, i)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ManyArgsReturns is a helper method to define mock.On call
//   - str string
//   - i int
func (_e *MockExpecterAndRolledVariadic_Expecter) ManyArgsReturns(str interface{}, i interface{}) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {
	return &MockExpecterAndRolledVariadic_ManyArgsReturns_Call{Call: _e.mock.On("ManyArgsReturns", str, i)}
}

func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {
	_c.Call.Return(strs, err)
	return _c
}

func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int) ([]string, error)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// NoArg is a helper method to define mock.On call
func (_e *MockExpecterAndRolledVariadic_Expecter) NoArg() *MockExpecterAndRolledVariadic_NoArg_Call {
	return &MockExpecterAndRolledVariadic_NoArg_Call{Call: _e.mock.On("NoArg")}
}

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

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

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

// NoReturn provides a mock function for the type MockExpecterAndRolledVariadic
func (_mock *MockExpecterAndRolledVariadic) NoReturn(str string) {
	_mock.Called(str)
	return
}

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

// NoReturn is a helper method to define mock.On call
//   - str string
func (_e *MockExpecterAndRolledVariadic_Expecter) NoReturn(str interface{}) *MockExpecterAndRolledVariadic_NoReturn_Call {
	return &MockExpecterAndRolledVariadic_NoReturn_Call{Call: _e.mock.On("NoReturn", str)}
}

func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Run(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_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 *MockExpecterAndRolledVariadic_NoReturn_Call) Return() *MockExpecterAndRolledVariadic_NoReturn_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call {
	_c.Run(run)
	return _c
}

// Variadic provides a mock function for the type MockExpecterAndRolledVariadic
func (_mock *MockExpecterAndRolledVariadic) Variadic(ints ...int) error {
	var tmpRet mock.Arguments
	if len(ints) > 0 {
		tmpRet = _mock.Called(ints)
	} else {
		tmpRet = _mock.Called()
	}
	ret := tmpRet

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

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

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

// Variadic is a helper method to define mock.On call
//   - ints ...int
func (_e *MockExpecterAndRolledVariadic_Expecter) Variadic(ints ...interface{}) *MockExpecterAndRolledVariadic_Variadic_Call {
	return &MockExpecterAndRolledVariadic_Variadic_Call{Call: _e.mock.On("Variadic",
		append([]interface{}{}, ints...)...)}
}

func (_c *MockExpecterAndRolledVariadic_Variadic_Call) Run(run func(ints ...int)) *MockExpecterAndRolledVariadic_Variadic_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []int
		var variadicArgs []int
		if len(args) > 0 {
			variadicArgs = args[0].([]int)
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockExpecterAndRolledVariadic_Variadic_Call) RunAndReturn(run func(ints ...int) error) *MockExpecterAndRolledVariadic_Variadic_Call {
	_c.Call.Return(run)
	return _c
}

// VariadicMany provides a mock function for the type MockExpecterAndRolledVariadic
func (_mock *MockExpecterAndRolledVariadic) VariadicMany(i int, a string, intfs ...interface{}) error {
	var tmpRet mock.Arguments
	if len(intfs) > 0 {
		tmpRet = _mock.Called(i, a, intfs)
	} else {
		tmpRet = _mock.Called(i, a)
	}
	ret := tmpRet

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok {
		r0 = returnFunc(i, a, intfs...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// VariadicMany is a helper method to define mock.On call
//   - i int
//   - a string
//   - intfs ...interface{}
func (_e *MockExpecterAndRolledVariadic_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}) *MockExpecterAndRolledVariadic_VariadicMany_Call {
	return &MockExpecterAndRolledVariadic_VariadicMany_Call{Call: _e.mock.On("VariadicMany",
		append([]interface{}{i, a}, intfs...)...)}
}

func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecterAndRolledVariadic_VariadicMany_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []interface{}
		var variadicArgs []interface{}
		if len(args) > 2 {
			variadicArgs = args[2].([]interface{})
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{}) error) *MockExpecterAndRolledVariadic_VariadicMany_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockExpecter is an autogenerated mock type for the Expecter type
type MockExpecter struct {
	mock.Mock
}

type MockExpecter_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExpecter) EXPECT() *MockExpecter_Expecter {
	return &MockExpecter_Expecter{mock: &_m.Mock}
}

// ManyArgsReturns provides a mock function for the type MockExpecter
func (_mock *MockExpecter) ManyArgsReturns(str string, i int) ([]string, error) {
	ret := _mock.Called(str, i)

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

	var r0 []string
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok {
		return returnFunc(str, i)
	}
	if returnFunc, ok := ret.Get(0).(func(string, int) []string); ok {
		r0 = returnFunc(str, i)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]string)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, int) error); ok {
		r1 = returnFunc(str, i)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ManyArgsReturns is a helper method to define mock.On call
//   - str string
//   - i int
func (_e *MockExpecter_Expecter) ManyArgsReturns(str interface{}, i interface{}) *MockExpecter_ManyArgsReturns_Call {
	return &MockExpecter_ManyArgsReturns_Call{Call: _e.mock.On("ManyArgsReturns", str, i)}
}

func (_c *MockExpecter_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecter_ManyArgsReturns_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockExpecter_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecter_ManyArgsReturns_Call {
	_c.Call.Return(strs, err)
	return _c
}

func (_c *MockExpecter_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int) ([]string, error)) *MockExpecter_ManyArgsReturns_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// NoArg is a helper method to define mock.On call
func (_e *MockExpecter_Expecter) NoArg() *MockExpecter_NoArg_Call {
	return &MockExpecter_NoArg_Call{Call: _e.mock.On("NoArg")}
}

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

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

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

// NoReturn provides a mock function for the type MockExpecter
func (_mock *MockExpecter) NoReturn(str string) {
	_mock.Called(str)
	return
}

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

// NoReturn is a helper method to define mock.On call
//   - str string
func (_e *MockExpecter_Expecter) NoReturn(str interface{}) *MockExpecter_NoReturn_Call {
	return &MockExpecter_NoReturn_Call{Call: _e.mock.On("NoReturn", str)}
}

func (_c *MockExpecter_NoReturn_Call) Run(run func(str string)) *MockExpecter_NoReturn_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 *MockExpecter_NoReturn_Call) Return() *MockExpecter_NoReturn_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockExpecter_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecter_NoReturn_Call {
	_c.Run(run)
	return _c
}

// Variadic provides a mock function for the type MockExpecter
func (_mock *MockExpecter) Variadic(ints ...int) error {
	// int
	_va := make([]interface{}, len(ints))
	for _i := range ints {
		_va[_i] = ints[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Variadic is a helper method to define mock.On call
//   - ints ...int
func (_e *MockExpecter_Expecter) Variadic(ints ...interface{}) *MockExpecter_Variadic_Call {
	return &MockExpecter_Variadic_Call{Call: _e.mock.On("Variadic",
		append([]interface{}{}, ints...)...)}
}

func (_c *MockExpecter_Variadic_Call) Run(run func(ints ...int)) *MockExpecter_Variadic_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []int
		variadicArgs := make([]int, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(int)
			}
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockExpecter_Variadic_Call) RunAndReturn(run func(ints ...int) error) *MockExpecter_Variadic_Call {
	_c.Call.Return(run)
	return _c
}

// VariadicMany provides a mock function for the type MockExpecter
func (_mock *MockExpecter) VariadicMany(i int, a string, intfs ...interface{}) error {
	var _ca []interface{}
	_ca = append(_ca, i, a)
	_ca = append(_ca, intfs...)
	ret := _mock.Called(_ca...)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok {
		r0 = returnFunc(i, a, intfs...)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// VariadicMany is a helper method to define mock.On call
//   - i int
//   - a string
//   - intfs ...interface{}
func (_e *MockExpecter_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}) *MockExpecter_VariadicMany_Call {
	return &MockExpecter_VariadicMany_Call{Call: _e.mock.On("VariadicMany",
		append([]interface{}{i, a}, intfs...)...)}
}

func (_c *MockExpecter_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecter_VariadicMany_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 []interface{}
		variadicArgs := make([]interface{}, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		arg2 = variadicArgs
		run(
			arg0,
			arg1,
			arg2...,
		)
	})
	return _c
}

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

func (_c *MockExpecter_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{}) error) *MockExpecter_VariadicMany_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockVariadicNoReturnInterface is an autogenerated mock type for the VariadicNoReturnInterface type
type MockVariadicNoReturnInterface struct {
	mock.Mock
}

type MockVariadicNoReturnInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVariadicNoReturnInterface) EXPECT() *MockVariadicNoReturnInterface_Expecter {
	return &MockVariadicNoReturnInterface_Expecter{mock: &_m.Mock}
}

// VariadicNoReturn provides a mock function for the type MockVariadicNoReturnInterface
func (_mock *MockVariadicNoReturnInterface) VariadicNoReturn(j int, is ...interface{}) {
	if len(is) > 0 {
		_mock.Called(j, is)
	} else {
		_mock.Called(j)
	}

	return
}

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

// VariadicNoReturn is a helper method to define mock.On call
//   - j int
//   - is ...interface{}
func (_e *MockVariadicNoReturnInterface_Expecter) VariadicNoReturn(j interface{}, is ...interface{}) *MockVariadicNoReturnInterface_VariadicNoReturn_Call {
	return &MockVariadicNoReturnInterface_VariadicNoReturn_Call{Call: _e.mock.On("VariadicNoReturn",
		append([]interface{}{j}, is...)...)}
}

func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Run(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) RunAndReturn(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockFuncArgsCollision is an autogenerated mock type for the FuncArgsCollision type
type MockFuncArgsCollision struct {
	mock.Mock
}

type MockFuncArgsCollision_Expecter struct {
	mock *mock.Mock
}

func (_m *MockFuncArgsCollision) EXPECT() *MockFuncArgsCollision_Expecter {
	return &MockFuncArgsCollision_Expecter{mock: &_m.Mock}
}

// Foo provides a mock function for the type MockFuncArgsCollision
func (_mock *MockFuncArgsCollision) Foo(ret interface{}) error {
	ret1 := _mock.Called(ret)

	if len(ret1) == 0 {
		panic("no return value specified for Foo")
	}

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

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

// Foo is a helper method to define mock.On call
//   - ret interface{}
func (_e *MockFuncArgsCollision_Expecter) Foo(ret interface{}) *MockFuncArgsCollision_Foo_Call {
	return &MockFuncArgsCollision_Foo_Call{Call: _e.mock.On("Foo", ret)}
}

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

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

func (_c *MockFuncArgsCollision_Foo_Call) RunAndReturn(run func(ret interface{}) error) *MockFuncArgsCollision_Foo_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockRequesterGenerics creates a new instance of MockRequesterGenerics. 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 NewMockRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
	~int | GenericType[int, GetInt]
	comparable
}](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	mock := &MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{}
	mock.Mock.Test(t)

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

	return mock
}

// MockRequesterGenerics is an autogenerated mock type for the RequesterGenerics type
type MockRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
	~int | GenericType[int, GetInt]
	comparable
}] struct {
	mock.Mock
}

type MockRequesterGenerics_Expecter[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
	~int | GenericType[int, GetInt]
	comparable
}] struct {
	mock *mock.Mock
}

func (_m *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) EXPECT() *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	return &MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{mock: &_m.Mock}
}

// GenericAnonymousStructs provides a mock function for the type MockRequesterGenerics
func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val struct{ Type1 TExternalIntf }) struct {
	Type2 GenericType[string, EmbeddedGet[int]]
} {
	ret := _mock.Called(val)

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

	var r0 struct {
		Type2 GenericType[string, EmbeddedGet[int]]
	}
	if returnFunc, ok := ret.Get(0).(func(struct{ Type1 TExternalIntf }) struct {
		Type2 GenericType[string, EmbeddedGet[int]]
	}); ok {
		r0 = returnFunc(val)
	} else {
		r0 = ret.Get(0).(struct {
			Type2 GenericType[string, EmbeddedGet[int]]
		})
	}
	return r0
}

// MockRequesterGenerics_GenericAnonymousStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericAnonymousStructs'
type MockRequesterGenerics_GenericAnonymousStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
	~int | GenericType[int, GetInt]
	comparable
}] struct {
	*mock.Call
}

// GenericAnonymousStructs is a helper method to define mock.On call
//   - val struct{Type1 TExternalIntf}
func (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val interface{}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	return &MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericAnonymousStructs", val)}
}

func (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(val struct{ Type1 TExternalIntf })) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 struct{ Type1 TExternalIntf }
		if args[0] != nil {
			arg0 = args[0].(struct{ Type1 TExternalIntf })
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(val1 struct {
	Type2 GenericType[string, EmbeddedGet[int]]
}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Return(val1)
	return _c
}

func (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(val struct{ Type1 TExternalIntf }) struct {
	Type2 GenericType[string, EmbeddedGet[int]]
}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Return(run)
	return _c
}

// GenericArguments provides a mock function for the type MockRequesterGenerics
func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v TAny, v1 TComparable) (TSigned, TIntf) {
	ret := _mock.Called(v, v1)

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

	var r0 TSigned
	var r1 TIntf
	if returnFunc, ok := ret.Get(0).(func(TAny, TComparable) (TSigned, TIntf)); ok {
		return returnFunc(v, v1)
	}
	if returnFunc, ok := ret.Get(0).(func(TAny, TComparable) TSigned); ok {
		r0 = returnFunc(v, v1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(TSigned)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(TAny, TComparable) TIntf); ok {
		r1 = returnFunc(v, v1)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(TIntf)
		}
	}
	return r0, r1
}

// MockRequesterGenerics_GenericArguments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericArguments'
type MockRequesterGenerics_GenericArguments_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
	~int | GenericType[int, GetInt]
	comparable
}] struct {
	*mock.Call
}

// GenericArguments is a helper method to define mock.On call
//   - v TAny
//   - v1 TComparable
func (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v interface{}, v1 interface{}) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	return &MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericArguments", v, v1)}
}

func (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(v TAny, v1 TComparable)) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 TAny
		if args[0] != nil {
			arg0 = args[0].(TAny)
		}
		var arg1 TComparable
		if args[1] != nil {
			arg1 = args[1].(TComparable)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(v2 TSigned, v3 TIntf) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Return(v2, v3)
	return _c
}

func (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(v TAny, v1 TComparable) (TSigned, TIntf)) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Return(run)
	return _c
}

// GenericStructs provides a mock function for the type MockRequesterGenerics
func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType GenericType[TAny, TIntf]) GenericType[TSigned, TIntf] {
	ret := _mock.Called(genericType)

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

	var r0 GenericType[TSigned, TIntf]
	if returnFunc, ok := ret.Get(0).(func(GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]); ok {
		r0 = returnFunc(genericType)
	} else {
		r0 = ret.Get(0).(GenericType[TSigned, TIntf])
	}
	return r0
}

// MockRequesterGenerics_GenericStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericStructs'
type MockRequesterGenerics_GenericStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{ ~int | ~uint }, TInlineTypeGeneric interface {
	~int | GenericType[int, GetInt]
	comparable
}] struct {
	*mock.Call
}

// GenericStructs is a helper method to define mock.On call
//   - genericType GenericType[TAny, TIntf]
func (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType interface{}) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	return &MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericStructs", genericType)}
}

func (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(genericType GenericType[TAny, TIntf])) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 GenericType[TAny, TIntf]
		if args[0] != nil {
			arg0 = args[0].(GenericType[TAny, TIntf])
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(genericType1 GenericType[TSigned, TIntf]) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Return(genericType1)
	return _c
}

func (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(genericType GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockGetInt is an autogenerated mock type for the GetInt type
type MockGetInt struct {
	mock.Mock
}

type MockGetInt_Expecter struct {
	mock *mock.Mock
}

func (_m *MockGetInt) EXPECT() *MockGetInt_Expecter {
	return &MockGetInt_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Get is a helper method to define mock.On call
func (_e *MockGetInt_Expecter) Get() *MockGetInt_Get_Call {
	return &MockGetInt_Get_Call{Call: _e.mock.On("Get")}
}

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

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

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

// NewMockGetGeneric creates a new instance of MockGetGeneric. 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 NewMockGetGeneric[T constraints.Integer](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGetGeneric[T] {
	mock := &MockGetGeneric[T]{}
	mock.Mock.Test(t)

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

	return mock
}

// MockGetGeneric is an autogenerated mock type for the GetGeneric type
type MockGetGeneric[T constraints.Integer] struct {
	mock.Mock
}

type MockGetGeneric_Expecter[T constraints.Integer] struct {
	mock *mock.Mock
}

func (_m *MockGetGeneric[T]) EXPECT() *MockGetGeneric_Expecter[T] {
	return &MockGetGeneric_Expecter[T]{mock: &_m.Mock}
}

// Get provides a mock function for the type MockGetGeneric
func (_mock *MockGetGeneric[T]) Get() T {
	ret := _mock.Called()

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

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

// MockGetGeneric_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
type MockGetGeneric_Get_Call[T constraints.Integer] struct {
	*mock.Call
}

// Get is a helper method to define mock.On call
func (_e *MockGetGeneric_Expecter[T]) Get() *MockGetGeneric_Get_Call[T] {
	return &MockGetGeneric_Get_Call[T]{Call: _e.mock.On("Get")}
}

func (_c *MockGetGeneric_Get_Call[T]) Run(run func()) *MockGetGeneric_Get_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockGetGeneric_Get_Call[T]) Return(v T) *MockGetGeneric_Get_Call[T] {
	_c.Call.Return(v)
	return _c
}

func (_c *MockGetGeneric_Get_Call[T]) RunAndReturn(run func() T) *MockGetGeneric_Get_Call[T] {
	_c.Call.Return(run)
	return _c
}

// NewMockEmbeddedGet creates a new instance of MockEmbeddedGet. 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 NewMockEmbeddedGet[T constraints.Signed](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEmbeddedGet[T] {
	mock := &MockEmbeddedGet[T]{}
	mock.Mock.Test(t)

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

	return mock
}

// MockEmbeddedGet is an autogenerated mock type for the EmbeddedGet type
type MockEmbeddedGet[T constraints.Signed] struct {
	mock.Mock
}

type MockEmbeddedGet_Expecter[T constraints.Signed] struct {
	mock *mock.Mock
}

func (_m *MockEmbeddedGet[T]) EXPECT() *MockEmbeddedGet_Expecter[T] {
	return &MockEmbeddedGet_Expecter[T]{mock: &_m.Mock}
}

// Get provides a mock function for the type MockEmbeddedGet
func (_mock *MockEmbeddedGet[T]) Get() T {
	ret := _mock.Called()

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

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

// MockEmbeddedGet_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
type MockEmbeddedGet_Get_Call[T constraints.Signed] struct {
	*mock.Call
}

// Get is a helper method to define mock.On call
func (_e *MockEmbeddedGet_Expecter[T]) Get() *MockEmbeddedGet_Get_Call[T] {
	return &MockEmbeddedGet_Get_Call[T]{Call: _e.mock.On("Get")}
}

func (_c *MockEmbeddedGet_Get_Call[T]) Run(run func()) *MockEmbeddedGet_Get_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockEmbeddedGet_Get_Call[T]) Return(v T) *MockEmbeddedGet_Get_Call[T] {
	_c.Call.Return(v)
	return _c
}

func (_c *MockEmbeddedGet_Get_Call[T]) RunAndReturn(run func() T) *MockEmbeddedGet_Get_Call[T] {
	_c.Call.Return(run)
	return _c
}

// NewMockReplaceGeneric creates a new instance of MockReplaceGeneric. 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 NewMockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReplaceGeneric[TImport, TConstraint, TKeep] {
	mock := &MockReplaceGeneric[TImport, TConstraint, TKeep]{}
	mock.Mock.Test(t)

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

	return mock
}

// MockReplaceGeneric is an autogenerated mock type for the ReplaceGeneric type
type MockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	mock.Mock
}

type MockReplaceGeneric_Expecter[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	mock *mock.Mock
}

func (_m *MockReplaceGeneric[TImport, TConstraint, TKeep]) EXPECT() *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep] {
	return &MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]{mock: &_m.Mock}
}

// A provides a mock function for the type MockReplaceGeneric
func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep {
	ret := _mock.Called(t1)

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

	var r0 TKeep
	if returnFunc, ok := ret.Get(0).(func(TImport) TKeep); ok {
		r0 = returnFunc(t1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(TKeep)
		}
	}
	return r0
}

// MockReplaceGeneric_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'
type MockReplaceGeneric_A_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	*mock.Call
}

// A is a helper method to define mock.On call
//   - t1 TImport
func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) A(t1 interface{}) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {
	return &MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("A", t1)}
}

func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Run(run func(t1 TImport)) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 TImport
		if args[0] != nil {
			arg0 = args[0].(TImport)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Return(v TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {
	_c.Call.Return(v)
	return _c
}

func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func(t1 TImport) TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] {
	_c.Call.Return(run)
	return _c
}

// B provides a mock function for the type MockReplaceGeneric
func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) B() TImport {
	ret := _mock.Called()

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

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

// MockReplaceGeneric_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'
type MockReplaceGeneric_B_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	*mock.Call
}

// B is a helper method to define mock.On call
func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) B() *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {
	return &MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("B")}
}

func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Return(v TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {
	_c.Call.Return(v)
	return _c
}

func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func() TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] {
	_c.Call.Return(run)
	return _c
}

// C provides a mock function for the type MockReplaceGeneric
func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) C() TConstraint {
	ret := _mock.Called()

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

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

// MockReplaceGeneric_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'
type MockReplaceGeneric_C_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	*mock.Call
}

// C is a helper method to define mock.On call
func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) C() *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {
	return &MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("C")}
}

func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Return(v TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {
	_c.Call.Return(v)
	return _c
}

func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func() TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] {
	_c.Call.Return(run)
	return _c
}

// NewMockReplaceGenericSelf creates a new instance of MockReplaceGenericSelf. 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 NewMockReplaceGenericSelf[T any](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReplaceGenericSelf[T] {
	mock := &MockReplaceGenericSelf[T]{}
	mock.Mock.Test(t)

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

	return mock
}

// MockReplaceGenericSelf is an autogenerated mock type for the ReplaceGenericSelf type
type MockReplaceGenericSelf[T any] struct {
	mock.Mock
}

type MockReplaceGenericSelf_Expecter[T any] struct {
	mock *mock.Mock
}

func (_m *MockReplaceGenericSelf[T]) EXPECT() *MockReplaceGenericSelf_Expecter[T] {
	return &MockReplaceGenericSelf_Expecter[T]{mock: &_m.Mock}
}

// A provides a mock function for the type MockReplaceGenericSelf
func (_mock *MockReplaceGenericSelf[T]) A() T {
	ret := _mock.Called()

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

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

// MockReplaceGenericSelf_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'
type MockReplaceGenericSelf_A_Call[T any] struct {
	*mock.Call
}

// A is a helper method to define mock.On call
func (_e *MockReplaceGenericSelf_Expecter[T]) A() *MockReplaceGenericSelf_A_Call[T] {
	return &MockReplaceGenericSelf_A_Call[T]{Call: _e.mock.On("A")}
}

func (_c *MockReplaceGenericSelf_A_Call[T]) Run(run func()) *MockReplaceGenericSelf_A_Call[T] {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockReplaceGenericSelf_A_Call[T]) Return(v T) *MockReplaceGenericSelf_A_Call[T] {
	_c.Call.Return(v)
	return _c
}

func (_c *MockReplaceGenericSelf_A_Call[T]) RunAndReturn(run func() T) *MockReplaceGenericSelf_A_Call[T] {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockHasConflictingNestedImports is an autogenerated mock type for the HasConflictingNestedImports type
type MockHasConflictingNestedImports struct {
	mock.Mock
}

type MockHasConflictingNestedImports_Expecter struct {
	mock *mock.Mock
}

func (_m *MockHasConflictingNestedImports) EXPECT() *MockHasConflictingNestedImports_Expecter {
	return &MockHasConflictingNestedImports_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockHasConflictingNestedImports
func (_mock *MockHasConflictingNestedImports) Get(path string) (http.Response, error) {
	ret := _mock.Called(path)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockHasConflictingNestedImports_Expecter) Get(path interface{}) *MockHasConflictingNestedImports_Get_Call {
	return &MockHasConflictingNestedImports_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockHasConflictingNestedImports_Get_Call) Run(run func(path string)) *MockHasConflictingNestedImports_Get_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 *MockHasConflictingNestedImports_Get_Call) Return(response http.Response, err error) *MockHasConflictingNestedImports_Get_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockHasConflictingNestedImports_Get_Call) RunAndReturn(run func(path string) (http.Response, error)) *MockHasConflictingNestedImports_Get_Call {
	_c.Call.Return(run)
	return _c
}

// Z provides a mock function for the type MockHasConflictingNestedImports
func (_mock *MockHasConflictingNestedImports) Z() http0.MyStruct {
	ret := _mock.Called()

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

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

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

// Z is a helper method to define mock.On call
func (_e *MockHasConflictingNestedImports_Expecter) Z() *MockHasConflictingNestedImports_Z_Call {
	return &MockHasConflictingNestedImports_Z_Call{Call: _e.mock.On("Z")}
}

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

func (_c *MockHasConflictingNestedImports_Z_Call) Return(myStruct http0.MyStruct) *MockHasConflictingNestedImports_Z_Call {
	_c.Call.Return(myStruct)
	return _c
}

func (_c *MockHasConflictingNestedImports_Z_Call) RunAndReturn(run func() http0.MyStruct) *MockHasConflictingNestedImports_Z_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockImportsSameAsPackage is an autogenerated mock type for the ImportsSameAsPackage type
type MockImportsSameAsPackage struct {
	mock.Mock
}

type MockImportsSameAsPackage_Expecter struct {
	mock *mock.Mock
}

func (_m *MockImportsSameAsPackage) EXPECT() *MockImportsSameAsPackage_Expecter {
	return &MockImportsSameAsPackage_Expecter{mock: &_m.Mock}
}

// A provides a mock function for the type MockImportsSameAsPackage
func (_mock *MockImportsSameAsPackage) A() test.B {
	ret := _mock.Called()

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

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

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

// A is a helper method to define mock.On call
func (_e *MockImportsSameAsPackage_Expecter) A() *MockImportsSameAsPackage_A_Call {
	return &MockImportsSameAsPackage_A_Call{Call: _e.mock.On("A")}
}

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

func (_c *MockImportsSameAsPackage_A_Call) Return(b test.B) *MockImportsSameAsPackage_A_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockImportsSameAsPackage_A_Call) RunAndReturn(run func() test.B) *MockImportsSameAsPackage_A_Call {
	_c.Call.Return(run)
	return _c
}

// B provides a mock function for the type MockImportsSameAsPackage
func (_mock *MockImportsSameAsPackage) B() KeyManager {
	ret := _mock.Called()

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

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

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

// B is a helper method to define mock.On call
func (_e *MockImportsSameAsPackage_Expecter) B() *MockImportsSameAsPackage_B_Call {
	return &MockImportsSameAsPackage_B_Call{Call: _e.mock.On("B")}
}

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

func (_c *MockImportsSameAsPackage_B_Call) Return(keyManager KeyManager) *MockImportsSameAsPackage_B_Call {
	_c.Call.Return(keyManager)
	return _c
}

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

// C provides a mock function for the type MockImportsSameAsPackage
func (_mock *MockImportsSameAsPackage) C(c C) {
	_mock.Called(c)
	return
}

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

// C is a helper method to define mock.On call
//   - c C
func (_e *MockImportsSameAsPackage_Expecter) C(c interface{}) *MockImportsSameAsPackage_C_Call {
	return &MockImportsSameAsPackage_C_Call{Call: _e.mock.On("C", c)}
}

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

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

func (_c *MockImportsSameAsPackage_C_Call) RunAndReturn(run func(c C)) *MockImportsSameAsPackage_C_Call {
	_c.Run(run)
	return _c
}

// NewMockGenericInterface creates a new instance of MockGenericInterface. 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 NewMockGenericInterface[M any](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGenericInterface[M] {
	mock := &MockGenericInterface[M]{}
	mock.Mock.Test(t)

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

	return mock
}

// MockGenericInterface is an autogenerated mock type for the GenericInterface type
type MockGenericInterface[M any] struct {
	mock.Mock
}

type MockGenericInterface_Expecter[M any] struct {
	mock *mock.Mock
}

func (_m *MockGenericInterface[M]) EXPECT() *MockGenericInterface_Expecter[M] {
	return &MockGenericInterface_Expecter[M]{mock: &_m.Mock}
}

// Func provides a mock function for the type MockGenericInterface
func (_mock *MockGenericInterface[M]) Func(arg *M) int {
	ret := _mock.Called(arg)

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

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

// MockGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'
type MockGenericInterface_Func_Call[M any] struct {
	*mock.Call
}

// Func is a helper method to define mock.On call
//   - arg *M
func (_e *MockGenericInterface_Expecter[M]) Func(arg interface{}) *MockGenericInterface_Func_Call[M] {
	return &MockGenericInterface_Func_Call[M]{Call: _e.mock.On("Func", arg)}
}

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

func (_c *MockGenericInterface_Func_Call[M]) Return(n int) *MockGenericInterface_Func_Call[M] {
	_c.Call.Return(n)
	return _c
}

func (_c *MockGenericInterface_Func_Call[M]) RunAndReturn(run func(arg *M) int) *MockGenericInterface_Func_Call[M] {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockInstantiatedGenericInterface is an autogenerated mock type for the InstantiatedGenericInterface type
type MockInstantiatedGenericInterface struct {
	mock.Mock
}

type MockInstantiatedGenericInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockInstantiatedGenericInterface) EXPECT() *MockInstantiatedGenericInterface_Expecter {
	return &MockInstantiatedGenericInterface_Expecter{mock: &_m.Mock}
}

// Func provides a mock function for the type MockInstantiatedGenericInterface
func (_mock *MockInstantiatedGenericInterface) Func(arg *float32) int {
	ret := _mock.Called(arg)

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

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

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

// Func is a helper method to define mock.On call
//   - arg *float32
func (_e *MockInstantiatedGenericInterface_Expecter) Func(arg interface{}) *MockInstantiatedGenericInterface_Func_Call {
	return &MockInstantiatedGenericInterface_Func_Call{Call: _e.mock.On("Func", arg)}
}

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

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

func (_c *MockInstantiatedGenericInterface_Func_Call) RunAndReturn(run func(arg *float32) int) *MockInstantiatedGenericInterface_Func_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockMyReader is an autogenerated mock type for the MyReader type
type MockMyReader struct {
	mock.Mock
}

type MockMyReader_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMyReader) EXPECT() *MockMyReader_Expecter {
	return &MockMyReader_Expecter{mock: &_m.Mock}
}

// Read provides a mock function for the type MockMyReader
func (_mock *MockMyReader) Read(p []byte) (int, error) {
	ret := _mock.Called(p)

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

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

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

// Read is a helper method to define mock.On call
//   - p []byte
func (_e *MockMyReader_Expecter) Read(p interface{}) *MockMyReader_Read_Call {
	return &MockMyReader_Read_Call{Call: _e.mock.On("Read", p)}
}

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

func (_c *MockMyReader_Read_Call) Return(n int, err error) *MockMyReader_Read_Call {
	_c.Call.Return(n, err)
	return _c
}

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

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

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

	return mock
}

// MockIssue766 is an autogenerated mock type for the Issue766 type
type MockIssue766 struct {
	mock.Mock
}

type MockIssue766_Expecter struct {
	mock *mock.Mock
}

func (_m *MockIssue766) EXPECT() *MockIssue766_Expecter {
	return &MockIssue766_Expecter{mock: &_m.Mock}
}

// FetchData provides a mock function for the type MockIssue766
func (_mock *MockIssue766) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error) {
	ret := _mock.Called(fetchFunc)

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

	var r0 []int
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) ([]int, error)); ok {
		return returnFunc(fetchFunc)
	}
	if returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) []int); ok {
		r0 = returnFunc(fetchFunc)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]int)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(func(x ...int) ([]int, error)) error); ok {
		r1 = returnFunc(fetchFunc)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// FetchData is a helper method to define mock.On call
//   - fetchFunc func(x ...int) ([]int, error)
func (_e *MockIssue766_Expecter) FetchData(fetchFunc interface{}) *MockIssue766_FetchData_Call {
	return &MockIssue766_FetchData_Call{Call: _e.mock.On("FetchData", fetchFunc)}
}

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

func (_c *MockIssue766_FetchData_Call) Return(ints []int, err error) *MockIssue766_FetchData_Call {
	_c.Call.Return(ints, err)
	return _c
}

func (_c *MockIssue766_FetchData_Call) RunAndReturn(run func(fetchFunc func(x ...int) ([]int, error)) ([]int, error)) *MockIssue766_FetchData_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockMapToInterface is an autogenerated mock type for the MapToInterface type
type MockMapToInterface struct {
	mock.Mock
}

type MockMapToInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockMapToInterface) EXPECT() *MockMapToInterface_Expecter {
	return &MockMapToInterface_Expecter{mock: &_m.Mock}
}

// Foo provides a mock function for the type MockMapToInterface
func (_mock *MockMapToInterface) Foo(arg1 ...map[string]interface{}) {
	if len(arg1) > 0 {
		_mock.Called(arg1)
	} else {
		_mock.Called()
	}

	return
}

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

// Foo is a helper method to define mock.On call
//   - arg1 ...map[string]interface{}
func (_e *MockMapToInterface_Expecter) Foo(arg1 ...interface{}) *MockMapToInterface_Foo_Call {
	return &MockMapToInterface_Foo_Call{Call: _e.mock.On("Foo",
		append([]interface{}{}, arg1...)...)}
}

func (_c *MockMapToInterface_Foo_Call) Run(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []map[string]interface{}
		var variadicArgs []map[string]interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]map[string]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockMapToInterface_Foo_Call) RunAndReturn(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockSibling is an autogenerated mock type for the Sibling type
type MockSibling struct {
	mock.Mock
}

type MockSibling_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSibling) EXPECT() *MockSibling_Expecter {
	return &MockSibling_Expecter{mock: &_m.Mock}
}

// DoSomething provides a mock function for the type MockSibling
func (_mock *MockSibling) DoSomething() {
	_mock.Called()
	return
}

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

// DoSomething is a helper method to define mock.On call
func (_e *MockSibling_Expecter) DoSomething() *MockSibling_DoSomething_Call {
	return &MockSibling_DoSomething_Call{Call: _e.mock.On("DoSomething")}
}

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

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

func (_c *MockSibling_DoSomething_Call) RunAndReturn(run func()) *MockSibling_DoSomething_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockUsesOtherPkgIface is an autogenerated mock type for the UsesOtherPkgIface type
type MockUsesOtherPkgIface struct {
	mock.Mock
}

type MockUsesOtherPkgIface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUsesOtherPkgIface) EXPECT() *MockUsesOtherPkgIface_Expecter {
	return &MockUsesOtherPkgIface_Expecter{mock: &_m.Mock}
}

// DoSomethingElse provides a mock function for the type MockUsesOtherPkgIface
func (_mock *MockUsesOtherPkgIface) DoSomethingElse(obj Sibling) {
	_mock.Called(obj)
	return
}

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

// DoSomethingElse is a helper method to define mock.On call
//   - obj Sibling
func (_e *MockUsesOtherPkgIface_Expecter) DoSomethingElse(obj interface{}) *MockUsesOtherPkgIface_DoSomethingElse_Call {
	return &MockUsesOtherPkgIface_DoSomethingElse_Call{Call: _e.mock.On("DoSomethingElse", obj)}
}

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

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

func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) RunAndReturn(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockNilRun is an autogenerated mock type for the NilRun type
type MockNilRun struct {
	mock.Mock
}

type MockNilRun_Expecter struct {
	mock *mock.Mock
}

func (_m *MockNilRun) EXPECT() *MockNilRun_Expecter {
	return &MockNilRun_Expecter{mock: &_m.Mock}
}

// Foo provides a mock function for the type MockNilRun
func (_mock *MockNilRun) Foo(nilRun NilRun) {
	_mock.Called(nilRun)
	return
}

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

// Foo is a helper method to define mock.On call
//   - nilRun NilRun
func (_e *MockNilRun_Expecter) Foo(nilRun interface{}) *MockNilRun_Foo_Call {
	return &MockNilRun_Foo_Call{Call: _e.mock.On("Foo", nilRun)}
}

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

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

func (_c *MockNilRun_Foo_Call) RunAndReturn(run func(nilRun NilRun)) *MockNilRun_Foo_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockPanicOnNoReturnValue is an autogenerated mock type for the PanicOnNoReturnValue type
type MockPanicOnNoReturnValue struct {
	mock.Mock
}

type MockPanicOnNoReturnValue_Expecter struct {
	mock *mock.Mock
}

func (_m *MockPanicOnNoReturnValue) EXPECT() *MockPanicOnNoReturnValue_Expecter {
	return &MockPanicOnNoReturnValue_Expecter{mock: &_m.Mock}
}

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

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

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

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

// DoSomething is a helper method to define mock.On call
func (_e *MockPanicOnNoReturnValue_Expecter) DoSomething() *MockPanicOnNoReturnValue_DoSomething_Call {
	return &MockPanicOnNoReturnValue_DoSomething_Call{Call: _e.mock.On("DoSomething")}
}

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

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

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

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

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

	return mock
}

// MockRequester is an autogenerated mock type for the Requester type
type MockRequester struct {
	mock.Mock
}

type MockRequester_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequester) EXPECT() *MockRequester_Expecter {
	return &MockRequester_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequester_Expecter) Get(path interface{}) *MockRequester_Get_Call {
	return &MockRequester_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequester_Get_Call) Run(run func(path string)) *MockRequester_Get_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 *MockRequester_Get_Call) Return(s string, err error) *MockRequester_Get_Call {
	_c.Call.Return(s, err)
	return _c
}

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

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

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

	return mock
}

// MockRequester2 is an autogenerated mock type for the Requester2 type
type MockRequester2 struct {
	mock.Mock
}

type MockRequester2_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequester2) EXPECT() *MockRequester2_Expecter {
	return &MockRequester2_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequester2
func (_mock *MockRequester2) Get(path string) error {
	ret := _mock.Called(path)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequester2_Expecter) Get(path interface{}) *MockRequester2_Get_Call {
	return &MockRequester2_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequester2_Get_Call) Run(run func(path string)) *MockRequester2_Get_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 *MockRequester2_Get_Call) Return(err error) *MockRequester2_Get_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockRequester2_Get_Call) RunAndReturn(run func(path string) error) *MockRequester2_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequester3 is an autogenerated mock type for the Requester3 type
type MockRequester3 struct {
	mock.Mock
}

type MockRequester3_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequester3) EXPECT() *MockRequester3_Expecter {
	return &MockRequester3_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Get is a helper method to define mock.On call
func (_e *MockRequester3_Expecter) Get() *MockRequester3_Get_Call {
	return &MockRequester3_Get_Call{Call: _e.mock.On("Get")}
}

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

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

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

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

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

	return mock
}

// MockRequester4 is an autogenerated mock type for the Requester4 type
type MockRequester4 struct {
	mock.Mock
}

type MockRequester4_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequester4) EXPECT() *MockRequester4_Expecter {
	return &MockRequester4_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequester4
func (_mock *MockRequester4) Get() {
	_mock.Called()
	return
}

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

// Get is a helper method to define mock.On call
func (_e *MockRequester4_Expecter) Get() *MockRequester4_Get_Call {
	return &MockRequester4_Get_Call{Call: _e.mock.On("Get")}
}

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

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

func (_c *MockRequester4_Get_Call) RunAndReturn(run func()) *MockRequester4_Get_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockRequesterArgSameAsImport is an autogenerated mock type for the RequesterArgSameAsImport type
type MockRequesterArgSameAsImport struct {
	mock.Mock
}

type MockRequesterArgSameAsImport_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterArgSameAsImport) EXPECT() *MockRequesterArgSameAsImport_Expecter {
	return &MockRequesterArgSameAsImport_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterArgSameAsImport
func (_mock *MockRequesterArgSameAsImport) Get(json1 string) *json.RawMessage {
	ret := _mock.Called(json1)

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

	var r0 *json.RawMessage
	if returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok {
		r0 = returnFunc(json1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*json.RawMessage)
		}
	}
	return r0
}

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

// Get is a helper method to define mock.On call
//   - json1 string
func (_e *MockRequesterArgSameAsImport_Expecter) Get(json1 interface{}) *MockRequesterArgSameAsImport_Get_Call {
	return &MockRequesterArgSameAsImport_Get_Call{Call: _e.mock.On("Get", json1)}
}

func (_c *MockRequesterArgSameAsImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsImport_Get_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 *MockRequesterArgSameAsImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call {
	_c.Call.Return(rawMessage)
	return _c
}

func (_c *MockRequesterArgSameAsImport_Get_Call) RunAndReturn(run func(json1 string) *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequesterArgSameAsNamedImport is an autogenerated mock type for the RequesterArgSameAsNamedImport type
type MockRequesterArgSameAsNamedImport struct {
	mock.Mock
}

type MockRequesterArgSameAsNamedImport_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterArgSameAsNamedImport) EXPECT() *MockRequesterArgSameAsNamedImport_Expecter {
	return &MockRequesterArgSameAsNamedImport_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterArgSameAsNamedImport
func (_mock *MockRequesterArgSameAsNamedImport) Get(json1 string) *json.RawMessage {
	ret := _mock.Called(json1)

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

	var r0 *json.RawMessage
	if returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok {
		r0 = returnFunc(json1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*json.RawMessage)
		}
	}
	return r0
}

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

// Get is a helper method to define mock.On call
//   - json1 string
func (_e *MockRequesterArgSameAsNamedImport_Expecter) Get(json1 interface{}) *MockRequesterArgSameAsNamedImport_Get_Call {
	return &MockRequesterArgSameAsNamedImport_Get_Call{Call: _e.mock.On("Get", json1)}
}

func (_c *MockRequesterArgSameAsNamedImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsNamedImport_Get_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 *MockRequesterArgSameAsNamedImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call {
	_c.Call.Return(rawMessage)
	return _c
}

func (_c *MockRequesterArgSameAsNamedImport_Get_Call) RunAndReturn(run func(json1 string) *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequesterArgSameAsPkg is an autogenerated mock type for the RequesterArgSameAsPkg type
type MockRequesterArgSameAsPkg struct {
	mock.Mock
}

type MockRequesterArgSameAsPkg_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterArgSameAsPkg) EXPECT() *MockRequesterArgSameAsPkg_Expecter {
	return &MockRequesterArgSameAsPkg_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterArgSameAsPkg
func (_mock *MockRequesterArgSameAsPkg) Get(test1 string) {
	_mock.Called(test1)
	return
}

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

// Get is a helper method to define mock.On call
//   - test1 string
func (_e *MockRequesterArgSameAsPkg_Expecter) Get(test1 interface{}) *MockRequesterArgSameAsPkg_Get_Call {
	return &MockRequesterArgSameAsPkg_Get_Call{Call: _e.mock.On("Get", test1)}
}

func (_c *MockRequesterArgSameAsPkg_Get_Call) Run(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_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 *MockRequesterArgSameAsPkg_Get_Call) Return() *MockRequesterArgSameAsPkg_Get_Call {
	_c.Call.Return()
	return _c
}

func (_c *MockRequesterArgSameAsPkg_Get_Call) RunAndReturn(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockRequesterArray is an autogenerated mock type for the RequesterArray type
type MockRequesterArray struct {
	mock.Mock
}

type MockRequesterArray_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterArray) EXPECT() *MockRequesterArray_Expecter {
	return &MockRequesterArray_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterArray
func (_mock *MockRequesterArray) Get(path string) ([2]string, error) {
	ret := _mock.Called(path)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequesterArray_Expecter) Get(path interface{}) *MockRequesterArray_Get_Call {
	return &MockRequesterArray_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequesterArray_Get_Call) Run(run func(path string)) *MockRequesterArray_Get_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 *MockRequesterArray_Get_Call) Return(strings [2]string, err error) *MockRequesterArray_Get_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockRequesterArray_Get_Call) RunAndReturn(run func(path string) ([2]string, error)) *MockRequesterArray_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequesterElided is an autogenerated mock type for the RequesterElided type
type MockRequesterElided struct {
	mock.Mock
}

type MockRequesterElided_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterElided) EXPECT() *MockRequesterElided_Expecter {
	return &MockRequesterElided_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterElided
func (_mock *MockRequesterElided) Get(path string, url string) error {
	ret := _mock.Called(path, url)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
//   - url string
func (_e *MockRequesterElided_Expecter) Get(path interface{}, url interface{}) *MockRequesterElided_Get_Call {
	return &MockRequesterElided_Get_Call{Call: _e.mock.On("Get", path, url)}
}

func (_c *MockRequesterElided_Get_Call) Run(run func(path string, url string)) *MockRequesterElided_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

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

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

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

	return mock
}

// MockRequesterIface is an autogenerated mock type for the RequesterIface type
type MockRequesterIface struct {
	mock.Mock
}

type MockRequesterIface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterIface) EXPECT() *MockRequesterIface_Expecter {
	return &MockRequesterIface_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterIface
func (_mock *MockRequesterIface) Get() io.Reader {
	ret := _mock.Called()

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

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

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

// Get is a helper method to define mock.On call
func (_e *MockRequesterIface_Expecter) Get() *MockRequesterIface_Get_Call {
	return &MockRequesterIface_Get_Call{Call: _e.mock.On("Get")}
}

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

func (_c *MockRequesterIface_Get_Call) Return(reader io.Reader) *MockRequesterIface_Get_Call {
	_c.Call.Return(reader)
	return _c
}

func (_c *MockRequesterIface_Get_Call) RunAndReturn(run func() io.Reader) *MockRequesterIface_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequesterNS is an autogenerated mock type for the RequesterNS type
type MockRequesterNS struct {
	mock.Mock
}

type MockRequesterNS_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterNS) EXPECT() *MockRequesterNS_Expecter {
	return &MockRequesterNS_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterNS
func (_mock *MockRequesterNS) Get(path string) (http.Response, error) {
	ret := _mock.Called(path)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequesterNS_Expecter) Get(path interface{}) *MockRequesterNS_Get_Call {
	return &MockRequesterNS_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequesterNS_Get_Call) Run(run func(path string)) *MockRequesterNS_Get_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 *MockRequesterNS_Get_Call) Return(response http.Response, err error) *MockRequesterNS_Get_Call {
	_c.Call.Return(response, err)
	return _c
}

func (_c *MockRequesterNS_Get_Call) RunAndReturn(run func(path string) (http.Response, error)) *MockRequesterNS_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequesterPtr is an autogenerated mock type for the RequesterPtr type
type MockRequesterPtr struct {
	mock.Mock
}

type MockRequesterPtr_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterPtr) EXPECT() *MockRequesterPtr_Expecter {
	return &MockRequesterPtr_Expecter{mock: &_m.Mock}
}

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

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequesterPtr_Expecter) Get(path interface{}) *MockRequesterPtr_Get_Call {
	return &MockRequesterPtr_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequesterPtr_Get_Call) Run(run func(path string)) *MockRequesterPtr_Get_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 *MockRequesterPtr_Get_Call) Return(s *string, err error) *MockRequesterPtr_Get_Call {
	_c.Call.Return(s, err)
	return _c
}

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

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

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

	return mock
}

// MockRequesterReturnElided is an autogenerated mock type for the RequesterReturnElided type
type MockRequesterReturnElided struct {
	mock.Mock
}

type MockRequesterReturnElided_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterReturnElided) EXPECT() *MockRequesterReturnElided_Expecter {
	return &MockRequesterReturnElided_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterReturnElided
func (_mock *MockRequesterReturnElided) Get(path string) (int, int, int, error) {
	ret := _mock.Called(path)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequesterReturnElided_Expecter) Get(path interface{}) *MockRequesterReturnElided_Get_Call {
	return &MockRequesterReturnElided_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequesterReturnElided_Get_Call) Run(run func(path string)) *MockRequesterReturnElided_Get_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 *MockRequesterReturnElided_Get_Call) Return(a int, b int, c int, err error) *MockRequesterReturnElided_Get_Call {
	_c.Call.Return(a, b, c, err)
	return _c
}

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

// Put provides a mock function for the type MockRequesterReturnElided
func (_mock *MockRequesterReturnElided) Put(path string) (int, error) {
	ret := _mock.Called(path)

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

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

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

// Put is a helper method to define mock.On call
//   - path string
func (_e *MockRequesterReturnElided_Expecter) Put(path interface{}) *MockRequesterReturnElided_Put_Call {
	return &MockRequesterReturnElided_Put_Call{Call: _e.mock.On("Put", path)}
}

func (_c *MockRequesterReturnElided_Put_Call) Run(run func(path string)) *MockRequesterReturnElided_Put_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 *MockRequesterReturnElided_Put_Call) Return(n int, err error) *MockRequesterReturnElided_Put_Call {
	_c.Call.Return(n, err)
	return _c
}

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

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

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

	return mock
}

// MockRequesterSlice is an autogenerated mock type for the RequesterSlice type
type MockRequesterSlice struct {
	mock.Mock
}

type MockRequesterSlice_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterSlice) EXPECT() *MockRequesterSlice_Expecter {
	return &MockRequesterSlice_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterSlice
func (_mock *MockRequesterSlice) Get(path string) ([]string, error) {
	ret := _mock.Called(path)

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

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

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

// Get is a helper method to define mock.On call
//   - path string
func (_e *MockRequesterSlice_Expecter) Get(path interface{}) *MockRequesterSlice_Get_Call {
	return &MockRequesterSlice_Get_Call{Call: _e.mock.On("Get", path)}
}

func (_c *MockRequesterSlice_Get_Call) Run(run func(path string)) *MockRequesterSlice_Get_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 *MockRequesterSlice_Get_Call) Return(strings []string, err error) *MockRequesterSlice_Get_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockRequesterSlice_Get_Call) RunAndReturn(run func(path string) ([]string, error)) *MockRequesterSlice_Get_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// mockrequesterUnexported is an autogenerated mock type for the requesterUnexported type
type mockrequesterUnexported struct {
	mock.Mock
}

type mockrequesterUnexported_Expecter struct {
	mock *mock.Mock
}

func (_m *mockrequesterUnexported) EXPECT() *mockrequesterUnexported_Expecter {
	return &mockrequesterUnexported_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type mockrequesterUnexported
func (_mock *mockrequesterUnexported) Get() {
	_mock.Called()
	return
}

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

// Get is a helper method to define mock.On call
func (_e *mockrequesterUnexported_Expecter) Get() *mockrequesterUnexported_Get_Call {
	return &mockrequesterUnexported_Get_Call{Call: _e.mock.On("Get")}
}

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

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

func (_c *mockrequesterUnexported_Get_Call) RunAndReturn(run func()) *mockrequesterUnexported_Get_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockRequesterVariadicOneArgument is an autogenerated mock type for the RequesterVariadic type
type MockRequesterVariadicOneArgument struct {
	mock.Mock
}

type MockRequesterVariadicOneArgument_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterVariadicOneArgument) EXPECT() *MockRequesterVariadicOneArgument_Expecter {
	return &MockRequesterVariadicOneArgument_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterVariadicOneArgument
func (_mock *MockRequesterVariadicOneArgument) Get(values ...string) bool {
	var tmpRet mock.Arguments
	if len(values) > 0 {
		tmpRet = _mock.Called(values)
	} else {
		tmpRet = _mock.Called()
	}
	ret := tmpRet

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

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

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

// Get is a helper method to define mock.On call
//   - values ...string
func (_e *MockRequesterVariadicOneArgument_Expecter) Get(values ...interface{}) *MockRequesterVariadicOneArgument_Get_Call {
	return &MockRequesterVariadicOneArgument_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{}, values...)...)}
}

func (_c *MockRequesterVariadicOneArgument_Get_Call) Run(run func(values ...string)) *MockRequesterVariadicOneArgument_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []string
		var variadicArgs []string
		if len(args) > 0 {
			variadicArgs = args[0].([]string)
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadicOneArgument_Get_Call) RunAndReturn(run func(values ...string) bool) *MockRequesterVariadicOneArgument_Get_Call {
	_c.Call.Return(run)
	return _c
}

// MultiWriteToFile provides a mock function for the type MockRequesterVariadicOneArgument
func (_mock *MockRequesterVariadicOneArgument) MultiWriteToFile(filename string, w ...io.Writer) string {
	var tmpRet mock.Arguments
	if len(w) > 0 {
		tmpRet = _mock.Called(filename, w)
	} else {
		tmpRet = _mock.Called(filename)
	}
	ret := tmpRet

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

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

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

// MultiWriteToFile is a helper method to define mock.On call
//   - filename string
//   - w ...io.Writer
func (_e *MockRequesterVariadicOneArgument_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {
	return &MockRequesterVariadicOneArgument_MultiWriteToFile_Call{Call: _e.mock.On("MultiWriteToFile",
		append([]interface{}{filename}, w...)...)}
}

func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []io.Writer
		var variadicArgs []io.Writer
		if len(args) > 1 {
			variadicArgs = args[1].([]io.Writer)
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer) string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call {
	_c.Call.Return(run)
	return _c
}

// OneInterface provides a mock function for the type MockRequesterVariadicOneArgument
func (_mock *MockRequesterVariadicOneArgument) OneInterface(a ...interface{}) bool {
	var tmpRet mock.Arguments
	if len(a) > 0 {
		tmpRet = _mock.Called(a)
	} else {
		tmpRet = _mock.Called()
	}
	ret := tmpRet

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

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

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

// OneInterface is a helper method to define mock.On call
//   - a ...interface{}
func (_e *MockRequesterVariadicOneArgument_Expecter) OneInterface(a ...interface{}) *MockRequesterVariadicOneArgument_OneInterface_Call {
	return &MockRequesterVariadicOneArgument_OneInterface_Call{Call: _e.mock.On("OneInterface",
		append([]interface{}{}, a...)...)}
}

func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadicOneArgument_OneInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		var variadicArgs []interface{}
		if len(args) > 0 {
			variadicArgs = args[0].([]interface{})
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) RunAndReturn(run func(a ...interface{}) bool) *MockRequesterVariadicOneArgument_OneInterface_Call {
	_c.Call.Return(run)
	return _c
}

// Sprintf provides a mock function for the type MockRequesterVariadicOneArgument
func (_mock *MockRequesterVariadicOneArgument) Sprintf(format string, a ...interface{}) string {
	var tmpRet mock.Arguments
	if len(a) > 0 {
		tmpRet = _mock.Called(format, a)
	} else {
		tmpRet = _mock.Called(format)
	}
	ret := tmpRet

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

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

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

// Sprintf is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *MockRequesterVariadicOneArgument_Expecter) Sprintf(format interface{}, a ...interface{}) *MockRequesterVariadicOneArgument_Sprintf_Call {
	return &MockRequesterVariadicOneArgument_Sprintf_Call{Call: _e.mock.On("Sprintf",
		append([]interface{}{format}, a...)...)}
}

func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadicOneArgument_Sprintf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		var variadicArgs []interface{}
		if len(args) > 1 {
			variadicArgs = args[1].([]interface{})
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockRequesterVariadicOneArgument_Sprintf_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockRequesterVariadic is an autogenerated mock type for the RequesterVariadic type
type MockRequesterVariadic struct {
	mock.Mock
}

type MockRequesterVariadic_Expecter struct {
	mock *mock.Mock
}

func (_m *MockRequesterVariadic) EXPECT() *MockRequesterVariadic_Expecter {
	return &MockRequesterVariadic_Expecter{mock: &_m.Mock}
}

// Get provides a mock function for the type MockRequesterVariadic
func (_mock *MockRequesterVariadic) Get(values ...string) bool {
	// string
	_va := make([]interface{}, len(values))
	for _i := range values {
		_va[_i] = values[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Get is a helper method to define mock.On call
//   - values ...string
func (_e *MockRequesterVariadic_Expecter) Get(values ...interface{}) *MockRequesterVariadic_Get_Call {
	return &MockRequesterVariadic_Get_Call{Call: _e.mock.On("Get",
		append([]interface{}{}, values...)...)}
}

func (_c *MockRequesterVariadic_Get_Call) Run(run func(values ...string)) *MockRequesterVariadic_Get_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []string
		variadicArgs := make([]string, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadic_Get_Call) RunAndReturn(run func(values ...string) bool) *MockRequesterVariadic_Get_Call {
	_c.Call.Return(run)
	return _c
}

// MultiWriteToFile provides a mock function for the type MockRequesterVariadic
func (_mock *MockRequesterVariadic) MultiWriteToFile(filename string, w ...io.Writer) string {
	// io.Writer
	_va := make([]interface{}, len(w))
	for _i := range w {
		_va[_i] = w[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, filename)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// MultiWriteToFile is a helper method to define mock.On call
//   - filename string
//   - w ...io.Writer
func (_e *MockRequesterVariadic_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}) *MockRequesterVariadic_MultiWriteToFile_Call {
	return &MockRequesterVariadic_MultiWriteToFile_Call{Call: _e.mock.On("MultiWriteToFile",
		append([]interface{}{filename}, w...)...)}
}

func (_c *MockRequesterVariadic_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadic_MultiWriteToFile_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []io.Writer
		variadicArgs := make([]io.Writer, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(io.Writer)
			}
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadic_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer) string) *MockRequesterVariadic_MultiWriteToFile_Call {
	_c.Call.Return(run)
	return _c
}

// OneInterface provides a mock function for the type MockRequesterVariadic
func (_mock *MockRequesterVariadic) OneInterface(a ...interface{}) bool {
	var _ca []interface{}
	_ca = append(_ca, a...)
	ret := _mock.Called(_ca...)

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

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

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

// OneInterface is a helper method to define mock.On call
//   - a ...interface{}
func (_e *MockRequesterVariadic_Expecter) OneInterface(a ...interface{}) *MockRequesterVariadic_OneInterface_Call {
	return &MockRequesterVariadic_OneInterface_Call{Call: _e.mock.On("OneInterface",
		append([]interface{}{}, a...)...)}
}

func (_c *MockRequesterVariadic_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadic_OneInterface_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []interface{}
		variadicArgs := make([]interface{}, len(args)-0)
		for i, a := range args[0:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		arg0 = variadicArgs
		run(
			arg0...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadic_OneInterface_Call) RunAndReturn(run func(a ...interface{}) bool) *MockRequesterVariadic_OneInterface_Call {
	_c.Call.Return(run)
	return _c
}

// Sprintf provides a mock function for the type MockRequesterVariadic
func (_mock *MockRequesterVariadic) Sprintf(format string, a ...interface{}) string {
	var _ca []interface{}
	_ca = append(_ca, format)
	_ca = append(_ca, a...)
	ret := _mock.Called(_ca...)

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

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

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

// Sprintf is a helper method to define mock.On call
//   - format string
//   - a ...interface{}
func (_e *MockRequesterVariadic_Expecter) Sprintf(format interface{}, a ...interface{}) *MockRequesterVariadic_Sprintf_Call {
	return &MockRequesterVariadic_Sprintf_Call{Call: _e.mock.On("Sprintf",
		append([]interface{}{format}, a...)...)}
}

func (_c *MockRequesterVariadic_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadic_Sprintf_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []interface{}
		variadicArgs := make([]interface{}, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(interface{})
			}
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockRequesterVariadic_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockRequesterVariadic_Sprintf_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockExample is an autogenerated mock type for the Example type
type MockExample struct {
	mock.Mock
}

type MockExample_Expecter struct {
	mock *mock.Mock
}

func (_m *MockExample) EXPECT() *MockExample_Expecter {
	return &MockExample_Expecter{mock: &_m.Mock}
}

// A provides a mock function for the type MockExample
func (_mock *MockExample) A() http.Flusher {
	ret := _mock.Called()

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

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

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

// A is a helper method to define mock.On call
func (_e *MockExample_Expecter) A() *MockExample_A_Call {
	return &MockExample_A_Call{Call: _e.mock.On("A")}
}

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

func (_c *MockExample_A_Call) Return(flusher http.Flusher) *MockExample_A_Call {
	_c.Call.Return(flusher)
	return _c
}

func (_c *MockExample_A_Call) RunAndReturn(run func() http.Flusher) *MockExample_A_Call {
	_c.Call.Return(run)
	return _c
}

// B provides a mock function for the type MockExample
func (_mock *MockExample) B(fixtureshttp string) http0.MyStruct {
	ret := _mock.Called(fixtureshttp)

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

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

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

// B is a helper method to define mock.On call
//   - fixtureshttp string
func (_e *MockExample_Expecter) B(fixtureshttp interface{}) *MockExample_B_Call {
	return &MockExample_B_Call{Call: _e.mock.On("B", fixtureshttp)}
}

func (_c *MockExample_B_Call) Run(run func(fixtureshttp string)) *MockExample_B_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 *MockExample_B_Call) Return(myStruct http0.MyStruct) *MockExample_B_Call {
	_c.Call.Return(myStruct)
	return _c
}

func (_c *MockExample_B_Call) RunAndReturn(run func(fixtureshttp string) http0.MyStruct) *MockExample_B_Call {
	_c.Call.Return(run)
	return _c
}

// C provides a mock function for the type MockExample
func (_mock *MockExample) C(fixtureshttp string) http1.MyStruct {
	ret := _mock.Called(fixtureshttp)

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

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

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

// C is a helper method to define mock.On call
//   - fixtureshttp string
func (_e *MockExample_Expecter) C(fixtureshttp interface{}) *MockExample_C_Call {
	return &MockExample_C_Call{Call: _e.mock.On("C", fixtureshttp)}
}

func (_c *MockExample_C_Call) Run(run func(fixtureshttp string)) *MockExample_C_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 *MockExample_C_Call) Return(myStruct http1.MyStruct) *MockExample_C_Call {
	_c.Call.Return(myStruct)
	return _c
}

func (_c *MockExample_C_Call) RunAndReturn(run func(fixtureshttp string) http1.MyStruct) *MockExample_C_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockA is an autogenerated mock type for the A type
type MockA struct {
	mock.Mock
}

type MockA_Expecter struct {
	mock *mock.Mock
}

func (_m *MockA) EXPECT() *MockA_Expecter {
	return &MockA_Expecter{mock: &_m.Mock}
}

// Call provides a mock function for the type MockA
func (_mock *MockA) Call() (B, error) {
	ret := _mock.Called()

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

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

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

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

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

func (_c *MockA_Call_Call) Return(b B, err error) *MockA_Call_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockA_Call_Call) RunAndReturn(run func() (B, error)) *MockA_Call_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockStructWithTag is an autogenerated mock type for the StructWithTag type
type MockStructWithTag struct {
	mock.Mock
}

type MockStructWithTag_Expecter struct {
	mock *mock.Mock
}

func (_m *MockStructWithTag) EXPECT() *MockStructWithTag_Expecter {
	return &MockStructWithTag_Expecter{mock: &_m.Mock}
}

// MethodA provides a mock function for the type MockStructWithTag
func (_mock *MockStructWithTag) MethodA(v *struct {
	FieldA int "json:\"field_a\""
	FieldB int "json:\"field_b\" xml:\"field_b\""
}) *struct {
	FieldC int "json:\"field_c\""
	FieldD int "json:\"field_d\" xml:\"field_d\""
} {
	ret := _mock.Called(v)

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

	var r0 *struct {
		FieldC int "json:\"field_c\""
		FieldD int "json:\"field_d\" xml:\"field_d\""
	}
	if returnFunc, ok := ret.Get(0).(func(*struct {
		FieldA int "json:\"field_a\""
		FieldB int "json:\"field_b\" xml:\"field_b\""
	}) *struct {
		FieldC int "json:\"field_c\""
		FieldD int "json:\"field_d\" xml:\"field_d\""
	}); ok {
		r0 = returnFunc(v)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*struct {
				FieldC int "json:\"field_c\""
				FieldD int "json:\"field_d\" xml:\"field_d\""
			})
		}
	}
	return r0
}

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

// MethodA is a helper method to define mock.On call
//   - v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}
func (_e *MockStructWithTag_Expecter) MethodA(v interface{}) *MockStructWithTag_MethodA_Call {
	return &MockStructWithTag_MethodA_Call{Call: _e.mock.On("MethodA", v)}
}

func (_c *MockStructWithTag_MethodA_Call) Run(run func(v *struct {
	FieldA int "json:\"field_a\""
	FieldB int "json:\"field_b\" xml:\"field_b\""
})) *MockStructWithTag_MethodA_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *struct {
			FieldA int "json:\"field_a\""
			FieldB int "json:\"field_b\" xml:\"field_b\""
		}
		if args[0] != nil {
			arg0 = args[0].(*struct {
				FieldA int "json:\"field_a\""
				FieldB int "json:\"field_b\" xml:\"field_b\""
			})
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockStructWithTag_MethodA_Call) Return(val *struct {
	FieldC int "json:\"field_c\""
	FieldD int "json:\"field_d\" xml:\"field_d\""
}) *MockStructWithTag_MethodA_Call {
	_c.Call.Return(val)
	return _c
}

func (_c *MockStructWithTag_MethodA_Call) RunAndReturn(run func(v *struct {
	FieldA int "json:\"field_a\""
	FieldB int "json:\"field_b\" xml:\"field_b\""
}) *struct {
	FieldC int "json:\"field_c\""
	FieldD int "json:\"field_d\" xml:\"field_d\""
}) *MockStructWithTag_MethodA_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockUnsafeInterface is an autogenerated mock type for the UnsafeInterface type
type MockUnsafeInterface struct {
	mock.Mock
}

type MockUnsafeInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *MockUnsafeInterface) EXPECT() *MockUnsafeInterface_Expecter {
	return &MockUnsafeInterface_Expecter{mock: &_m.Mock}
}

// Do provides a mock function for the type MockUnsafeInterface
func (_mock *MockUnsafeInterface) Do(ptr *unsafe.Pointer) {
	_mock.Called(ptr)
	return
}

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

// Do is a helper method to define mock.On call
//   - ptr *unsafe.Pointer
func (_e *MockUnsafeInterface_Expecter) Do(ptr interface{}) *MockUnsafeInterface_Do_Call {
	return &MockUnsafeInterface_Do_Call{Call: _e.mock.On("Do", ptr)}
}

func (_c *MockUnsafeInterface_Do_Call) Run(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *unsafe.Pointer
		if args[0] != nil {
			arg0 = args[0].(*unsafe.Pointer)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

func (_c *MockUnsafeInterface_Do_Call) RunAndReturn(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call {
	_c.Run(run)
	return _c
}

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

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

	return mock
}

// MockVariadic is an autogenerated mock type for the Variadic type
type MockVariadic struct {
	mock.Mock
}

type MockVariadic_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVariadic) EXPECT() *MockVariadic_Expecter {
	return &MockVariadic_Expecter{mock: &_m.Mock}
}

// VariadicFunction provides a mock function for the type MockVariadic
func (_mock *MockVariadic) VariadicFunction(str string, vFunc VariadicFunction) error {
	ret := _mock.Called(str, vFunc)

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

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

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

// VariadicFunction is a helper method to define mock.On call
//   - str string
//   - vFunc VariadicFunction
func (_e *MockVariadic_Expecter) VariadicFunction(str interface{}, vFunc interface{}) *MockVariadic_VariadicFunction_Call {
	return &MockVariadic_VariadicFunction_Call{Call: _e.mock.On("VariadicFunction", str, vFunc)}
}

func (_c *MockVariadic_VariadicFunction_Call) Run(run func(str string, vFunc VariadicFunction)) *MockVariadic_VariadicFunction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 VariadicFunction
		if args[1] != nil {
			arg1 = args[1].(VariadicFunction)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockVariadic_VariadicFunction_Call) RunAndReturn(run func(str string, vFunc VariadicFunction) error) *MockVariadic_VariadicFunction_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockVariadicReturnFunc is an autogenerated mock type for the VariadicReturnFunc type
type MockVariadicReturnFunc struct {
	mock.Mock
}

type MockVariadicReturnFunc_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVariadicReturnFunc) EXPECT() *MockVariadicReturnFunc_Expecter {
	return &MockVariadicReturnFunc_Expecter{mock: &_m.Mock}
}

// SampleMethod provides a mock function for the type MockVariadicReturnFunc
func (_mock *MockVariadicReturnFunc) SampleMethod(str string) func(str string, arr []int, a ...interface{}) {
	ret := _mock.Called(str)

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

	var r0 func(str string, arr []int, a ...interface{})
	if returnFunc, ok := ret.Get(0).(func(string) func(str string, arr []int, a ...interface{})); ok {
		r0 = returnFunc(str)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(func(str string, arr []int, a ...interface{}))
		}
	}
	return r0
}

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

// SampleMethod is a helper method to define mock.On call
//   - str string
func (_e *MockVariadicReturnFunc_Expecter) SampleMethod(str interface{}) *MockVariadicReturnFunc_SampleMethod_Call {
	return &MockVariadicReturnFunc_SampleMethod_Call{Call: _e.mock.On("SampleMethod", str)}
}

func (_c *MockVariadicReturnFunc_SampleMethod_Call) Run(run func(str string)) *MockVariadicReturnFunc_SampleMethod_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 *MockVariadicReturnFunc_SampleMethod_Call) Return(fn func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call {
	_c.Call.Return(fn)
	return _c
}

func (_c *MockVariadicReturnFunc_SampleMethod_Call) RunAndReturn(run func(str string) func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}

// MockVariadicWithMultipleReturnsUnrollVariadic is an autogenerated mock type for the VariadicWithMultipleReturns type
type MockVariadicWithMultipleReturnsUnrollVariadic struct {
	mock.Mock
}

type MockVariadicWithMultipleReturnsUnrollVariadic_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVariadicWithMultipleReturnsUnrollVariadic) EXPECT() *MockVariadicWithMultipleReturnsUnrollVariadic_Expecter {
	return &MockVariadicWithMultipleReturnsUnrollVariadic_Expecter{mock: &_m.Mock}
}

// Foo provides a mock function for the type MockVariadicWithMultipleReturnsUnrollVariadic
func (_mock *MockVariadicWithMultipleReturnsUnrollVariadic) Foo(one string, two ...string) (string, error) {
	// string
	_va := make([]interface{}, len(two))
	for _i := range two {
		_va[_i] = two[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, one)
	_ca = append(_ca, _va...)
	ret := _mock.Called(_ca...)

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

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

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

// Foo is a helper method to define mock.On call
//   - one string
//   - two ...string
func (_e *MockVariadicWithMultipleReturnsUnrollVariadic_Expecter) Foo(one interface{}, two ...interface{}) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {
	return &MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call{Call: _e.mock.On("Foo",
		append([]interface{}{one}, two...)...)}
}

func (_c *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call) Run(run func(one string, two ...string)) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []string
		variadicArgs := make([]string, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call) Return(result string, err error) *MockVariadicWithMultipleReturnsUnrollVariadic_Foo_Call {
	_c.Call.Return(result, err)
	return _c
}

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

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

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

	return mock
}

// MockVariadicWithMultipleReturns is an autogenerated mock type for the VariadicWithMultipleReturns type
type MockVariadicWithMultipleReturns struct {
	mock.Mock
}

type MockVariadicWithMultipleReturns_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVariadicWithMultipleReturns) EXPECT() *MockVariadicWithMultipleReturns_Expecter {
	return &MockVariadicWithMultipleReturns_Expecter{mock: &_m.Mock}
}

// Foo provides a mock function for the type MockVariadicWithMultipleReturns
func (_mock *MockVariadicWithMultipleReturns) Foo(one string, two ...string) (string, error) {
	var tmpRet mock.Arguments
	if len(two) > 0 {
		tmpRet = _mock.Called(one, two)
	} else {
		tmpRet = _mock.Called(one)
	}
	ret := tmpRet

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

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

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

// Foo is a helper method to define mock.On call
//   - one string
//   - two ...string
func (_e *MockVariadicWithMultipleReturns_Expecter) Foo(one interface{}, two ...interface{}) *MockVariadicWithMultipleReturns_Foo_Call {
	return &MockVariadicWithMultipleReturns_Foo_Call{Call: _e.mock.On("Foo",
		append([]interface{}{one}, two...)...)}
}

func (_c *MockVariadicWithMultipleReturns_Foo_Call) Run(run func(one string, two ...string)) *MockVariadicWithMultipleReturns_Foo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []string
		var variadicArgs []string
		if len(args) > 1 {
			variadicArgs = args[1].([]string)
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

func (_c *MockVariadicWithMultipleReturns_Foo_Call) Return(result string, err error) *MockVariadicWithMultipleReturns_Foo_Call {
	_c.Call.Return(result, err)
	return _c
}

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

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

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

	return mock
}

// MockVariadicWithNoReturns is an autogenerated mock type for the VariadicWithNoReturns type
type MockVariadicWithNoReturns struct {
	mock.Mock
}

type MockVariadicWithNoReturns_Expecter struct {
	mock *mock.Mock
}

func (_m *MockVariadicWithNoReturns) EXPECT() *MockVariadicWithNoReturns_Expecter {
	return &MockVariadicWithNoReturns_Expecter{mock: &_m.Mock}
}

// Foo provides a mock function for the type MockVariadicWithNoReturns
func (_mock *MockVariadicWithNoReturns) Foo(one string, two ...string) {
	// string
	_va := make([]interface{}, len(two))
	for _i := range two {
		_va[_i] = two[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, one)
	_ca = append(_ca, _va...)
	_mock.Called(_ca...)
	return
}

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

// Foo is a helper method to define mock.On call
//   - one string
//   - two ...string
func (_e *MockVariadicWithNoReturns_Expecter) Foo(one interface{}, two ...interface{}) *MockVariadicWithNoReturns_Foo_Call {
	return &MockVariadicWithNoReturns_Foo_Call{Call: _e.mock.On("Foo",
		append([]interface{}{one}, two...)...)}
}

func (_c *MockVariadicWithNoReturns_Foo_Call) Run(run func(one string, two ...string)) *MockVariadicWithNoReturns_Foo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 []string
		variadicArgs := make([]string, len(args)-1)
		for i, a := range args[1:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		arg1 = variadicArgs
		run(
			arg0,
			arg1...,
		)
	})
	return _c
}

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

func (_c *MockVariadicWithNoReturns_Foo_Call) RunAndReturn(run func(one string, two ...string)) *MockVariadicWithNoReturns_Foo_Call {
	_c.Run(run)
	return _c
}
