// Code generated by MockGen. DO NOT EDIT.
// Source: external.go
//
// Generated by this command:
//
//	mockgen --source=external.go --destination=source/mock_external_test.go --package source -typed
//

// Package source is a generated GoMock package.
package source

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	typed "go.uber.org/mock/mockgen/internal/tests/typed"
	other "go.uber.org/mock/mockgen/internal/tests/typed/other"
	constraints "golang.org/x/exp/constraints"
)

// MockExternalConstraint is a mock of ExternalConstraint interface.
type MockExternalConstraint[I constraints.Integer, F constraints.Float] struct {
	ctrl     *gomock.Controller
	recorder *MockExternalConstraintMockRecorder[I, F]
	isgomock struct{}
}

// MockExternalConstraintMockRecorder is the mock recorder for MockExternalConstraint.
type MockExternalConstraintMockRecorder[I constraints.Integer, F constraints.Float] struct {
	mock *MockExternalConstraint[I, F]
}

// NewMockExternalConstraint creates a new mock instance.
func NewMockExternalConstraint[I constraints.Integer, F constraints.Float](ctrl *gomock.Controller) *MockExternalConstraint[I, F] {
	mock := &MockExternalConstraint[I, F]{ctrl: ctrl}
	mock.recorder = &MockExternalConstraintMockRecorder[I, F]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockExternalConstraint[I, F]) EXPECT() *MockExternalConstraintMockRecorder[I, F] {
	return m.recorder
}

// Eight mocks base method.
func (m *MockExternalConstraint[I, F]) Eight(arg0 F) other.Two[I, F] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Eight", arg0)
	ret0, _ := ret[0].(other.Two[I, F])
	return ret0
}

// Eight indicates an expected call of Eight.
func (mr *MockExternalConstraintMockRecorder[I, F]) Eight(arg0 any) *MockExternalConstraintEightCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Eight), arg0)
	return &MockExternalConstraintEightCall[I, F]{Call: call}
}

// MockExternalConstraintEightCall wrap *gomock.Call
type MockExternalConstraintEightCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintEightCall[I, F]) Return(arg0 other.Two[I, F]) *MockExternalConstraintEightCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintEightCall[I, F]) Do(f func(F) other.Two[I, F]) *MockExternalConstraintEightCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintEightCall[I, F]) DoAndReturn(f func(F) other.Two[I, F]) *MockExternalConstraintEightCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Five mocks base method.
func (m *MockExternalConstraint[I, F]) Five(arg0 I) typed.Baz[F] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Five", arg0)
	ret0, _ := ret[0].(typed.Baz[F])
	return ret0
}

// Five indicates an expected call of Five.
func (mr *MockExternalConstraintMockRecorder[I, F]) Five(arg0 any) *MockExternalConstraintFiveCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Five), arg0)
	return &MockExternalConstraintFiveCall[I, F]{Call: call}
}

// MockExternalConstraintFiveCall wrap *gomock.Call
type MockExternalConstraintFiveCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintFiveCall[I, F]) Return(arg0 typed.Baz[F]) *MockExternalConstraintFiveCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintFiveCall[I, F]) Do(f func(I) typed.Baz[F]) *MockExternalConstraintFiveCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintFiveCall[I, F]) DoAndReturn(f func(I) typed.Baz[F]) *MockExternalConstraintFiveCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Four mocks base method.
func (m *MockExternalConstraint[I, F]) Four(arg0 I) typed.Foo[I, F] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Four", arg0)
	ret0, _ := ret[0].(typed.Foo[I, F])
	return ret0
}

// Four indicates an expected call of Four.
func (mr *MockExternalConstraintMockRecorder[I, F]) Four(arg0 any) *MockExternalConstraintFourCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Four), arg0)
	return &MockExternalConstraintFourCall[I, F]{Call: call}
}

// MockExternalConstraintFourCall wrap *gomock.Call
type MockExternalConstraintFourCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintFourCall[I, F]) Return(arg0 typed.Foo[I, F]) *MockExternalConstraintFourCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintFourCall[I, F]) Do(f func(I) typed.Foo[I, F]) *MockExternalConstraintFourCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintFourCall[I, F]) DoAndReturn(f func(I) typed.Foo[I, F]) *MockExternalConstraintFourCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Nine mocks base method.
func (m *MockExternalConstraint[I, F]) Nine(arg0 typed.Iface[I]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Nine", arg0)
}

// Nine indicates an expected call of Nine.
func (mr *MockExternalConstraintMockRecorder[I, F]) Nine(arg0 any) *MockExternalConstraintNineCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Nine), arg0)
	return &MockExternalConstraintNineCall[I, F]{Call: call}
}

// MockExternalConstraintNineCall wrap *gomock.Call
type MockExternalConstraintNineCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintNineCall[I, F]) Return() *MockExternalConstraintNineCall[I, F] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintNineCall[I, F]) Do(f func(typed.Iface[I])) *MockExternalConstraintNineCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintNineCall[I, F]) DoAndReturn(f func(typed.Iface[I])) *MockExternalConstraintNineCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// One mocks base method.
func (m *MockExternalConstraint[I, F]) One(arg0 string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "One", arg0)
	ret0, _ := ret[0].(string)
	return ret0
}

// One indicates an expected call of One.
func (mr *MockExternalConstraintMockRecorder[I, F]) One(arg0 any) *MockExternalConstraintOneCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).One), arg0)
	return &MockExternalConstraintOneCall[I, F]{Call: call}
}

// MockExternalConstraintOneCall wrap *gomock.Call
type MockExternalConstraintOneCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintOneCall[I, F]) Return(arg0 string) *MockExternalConstraintOneCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintOneCall[I, F]) Do(f func(string) string) *MockExternalConstraintOneCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintOneCall[I, F]) DoAndReturn(f func(string) string) *MockExternalConstraintOneCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Seven mocks base method.
func (m *MockExternalConstraint[I, F]) Seven(arg0 I) other.One[I] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seven", arg0)
	ret0, _ := ret[0].(other.One[I])
	return ret0
}

// Seven indicates an expected call of Seven.
func (mr *MockExternalConstraintMockRecorder[I, F]) Seven(arg0 any) *MockExternalConstraintSevenCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Seven), arg0)
	return &MockExternalConstraintSevenCall[I, F]{Call: call}
}

// MockExternalConstraintSevenCall wrap *gomock.Call
type MockExternalConstraintSevenCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintSevenCall[I, F]) Return(arg0 other.One[I]) *MockExternalConstraintSevenCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintSevenCall[I, F]) Do(f func(I) other.One[I]) *MockExternalConstraintSevenCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintSevenCall[I, F]) DoAndReturn(f func(I) other.One[I]) *MockExternalConstraintSevenCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Six mocks base method.
func (m *MockExternalConstraint[I, F]) Six(arg0 I) *typed.Baz[F] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Six", arg0)
	ret0, _ := ret[0].(*typed.Baz[F])
	return ret0
}

// Six indicates an expected call of Six.
func (mr *MockExternalConstraintMockRecorder[I, F]) Six(arg0 any) *MockExternalConstraintSixCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Six), arg0)
	return &MockExternalConstraintSixCall[I, F]{Call: call}
}

// MockExternalConstraintSixCall wrap *gomock.Call
type MockExternalConstraintSixCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintSixCall[I, F]) Return(arg0 *typed.Baz[F]) *MockExternalConstraintSixCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintSixCall[I, F]) Do(f func(I) *typed.Baz[F]) *MockExternalConstraintSixCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintSixCall[I, F]) DoAndReturn(f func(I) *typed.Baz[F]) *MockExternalConstraintSixCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Ten mocks base method.
func (m *MockExternalConstraint[I, F]) Ten(arg0 *I) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Ten", arg0)
}

// Ten indicates an expected call of Ten.
func (mr *MockExternalConstraintMockRecorder[I, F]) Ten(arg0 any) *MockExternalConstraintTenCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Ten), arg0)
	return &MockExternalConstraintTenCall[I, F]{Call: call}
}

// MockExternalConstraintTenCall wrap *gomock.Call
type MockExternalConstraintTenCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintTenCall[I, F]) Return() *MockExternalConstraintTenCall[I, F] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintTenCall[I, F]) Do(f func(*I)) *MockExternalConstraintTenCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintTenCall[I, F]) DoAndReturn(f func(*I)) *MockExternalConstraintTenCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Three mocks base method.
func (m *MockExternalConstraint[I, F]) Three(arg0 I) F {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Three", arg0)
	ret0, _ := ret[0].(F)
	return ret0
}

// Three indicates an expected call of Three.
func (mr *MockExternalConstraintMockRecorder[I, F]) Three(arg0 any) *MockExternalConstraintThreeCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Three), arg0)
	return &MockExternalConstraintThreeCall[I, F]{Call: call}
}

// MockExternalConstraintThreeCall wrap *gomock.Call
type MockExternalConstraintThreeCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintThreeCall[I, F]) Return(arg0 F) *MockExternalConstraintThreeCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintThreeCall[I, F]) Do(f func(I) F) *MockExternalConstraintThreeCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintThreeCall[I, F]) DoAndReturn(f func(I) F) *MockExternalConstraintThreeCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Two mocks base method.
func (m *MockExternalConstraint[I, F]) Two(arg0 I) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Two", arg0)
	ret0, _ := ret[0].(string)
	return ret0
}

// Two indicates an expected call of Two.
func (mr *MockExternalConstraintMockRecorder[I, F]) Two(arg0 any) *MockExternalConstraintTwoCall[I, F] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockExternalConstraint[I, F])(nil).Two), arg0)
	return &MockExternalConstraintTwoCall[I, F]{Call: call}
}

// MockExternalConstraintTwoCall wrap *gomock.Call
type MockExternalConstraintTwoCall[I constraints.Integer, F constraints.Float] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockExternalConstraintTwoCall[I, F]) Return(arg0 string) *MockExternalConstraintTwoCall[I, F] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockExternalConstraintTwoCall[I, F]) Do(f func(I) string) *MockExternalConstraintTwoCall[I, F] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockExternalConstraintTwoCall[I, F]) DoAndReturn(f func(I) string) *MockExternalConstraintTwoCall[I, F] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
