// Code generated by MockGen. DO NOT EDIT.
// Source: generics.go
//
// Generated by this command:
//
//	mockgen --source=generics.go --destination=source/mock_generics_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"
)

// MockBar is a mock of Bar interface.
type MockBar[T any, R any] struct {
	ctrl     *gomock.Controller
	recorder *MockBarMockRecorder[T, R]
	isgomock struct{}
}

// MockBarMockRecorder is the mock recorder for MockBar.
type MockBarMockRecorder[T any, R any] struct {
	mock *MockBar[T, R]
}

// NewMockBar creates a new mock instance.
func NewMockBar[T any, R any](ctrl *gomock.Controller) *MockBar[T, R] {
	mock := &MockBar[T, R]{ctrl: ctrl}
	mock.recorder = &MockBarMockRecorder[T, R]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBar[T, R]) EXPECT() *MockBarMockRecorder[T, R] {
	return m.recorder
}

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

// Eight indicates an expected call of Eight.
func (mr *MockBarMockRecorder[T, R]) Eight(arg0 any) *MockBarEightCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eight", reflect.TypeOf((*MockBar[T, R])(nil).Eight), arg0)
	return &MockBarEightCall[T, R]{Call: call}
}

// MockBarEightCall wrap *gomock.Call
type MockBarEightCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarEightCall[T, R]) Return(arg0 other.Two[T, R]) *MockBarEightCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarEightCall[T, R]) Do(f func(T) other.Two[T, R]) *MockBarEightCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarEightCall[T, R]) DoAndReturn(f func(T) other.Two[T, R]) *MockBarEightCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Eighteen mocks base method.
func (m *MockBar[T, R]) Eighteen() (typed.Iface[*other.Five], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Eighteen")
	ret0, _ := ret[0].(typed.Iface[*other.Five])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Eighteen indicates an expected call of Eighteen.
func (mr *MockBarMockRecorder[T, R]) Eighteen() *MockBarEighteenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eighteen", reflect.TypeOf((*MockBar[T, R])(nil).Eighteen))
	return &MockBarEighteenCall[T, R]{Call: call}
}

// MockBarEighteenCall wrap *gomock.Call
type MockBarEighteenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarEighteenCall[T, R]) Return(arg0 typed.Iface[*other.Five], arg1 error) *MockBarEighteenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarEighteenCall[T, R]) Do(f func() (typed.Iface[*other.Five], error)) *MockBarEighteenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarEighteenCall[T, R]) DoAndReturn(f func() (typed.Iface[*other.Five], error)) *MockBarEighteenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Eleven mocks base method.
func (m *MockBar[T, R]) Eleven() (*other.One[T], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Eleven")
	ret0, _ := ret[0].(*other.One[T])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Eleven indicates an expected call of Eleven.
func (mr *MockBarMockRecorder[T, R]) Eleven() *MockBarElevenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eleven", reflect.TypeOf((*MockBar[T, R])(nil).Eleven))
	return &MockBarElevenCall[T, R]{Call: call}
}

// MockBarElevenCall wrap *gomock.Call
type MockBarElevenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarElevenCall[T, R]) Return(arg0 *other.One[T], arg1 error) *MockBarElevenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarElevenCall[T, R]) Do(f func() (*other.One[T], error)) *MockBarElevenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarElevenCall[T, R]) DoAndReturn(f func() (*other.One[T], error)) *MockBarElevenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Fifteen mocks base method.
func (m *MockBar[T, R]) Fifteen() (typed.Iface[typed.StructType], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fifteen")
	ret0, _ := ret[0].(typed.Iface[typed.StructType])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fifteen indicates an expected call of Fifteen.
func (mr *MockBarMockRecorder[T, R]) Fifteen() *MockBarFifteenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fifteen", reflect.TypeOf((*MockBar[T, R])(nil).Fifteen))
	return &MockBarFifteenCall[T, R]{Call: call}
}

// MockBarFifteenCall wrap *gomock.Call
type MockBarFifteenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarFifteenCall[T, R]) Return(arg0 typed.Iface[typed.StructType], arg1 error) *MockBarFifteenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarFifteenCall[T, R]) Do(f func() (typed.Iface[typed.StructType], error)) *MockBarFifteenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarFifteenCall[T, R]) DoAndReturn(f func() (typed.Iface[typed.StructType], error)) *MockBarFifteenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Five indicates an expected call of Five.
func (mr *MockBarMockRecorder[T, R]) Five(arg0 any) *MockBarFiveCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Five", reflect.TypeOf((*MockBar[T, R])(nil).Five), arg0)
	return &MockBarFiveCall[T, R]{Call: call}
}

// MockBarFiveCall wrap *gomock.Call
type MockBarFiveCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarFiveCall[T, R]) Return(arg0 typed.Baz[T]) *MockBarFiveCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarFiveCall[T, R]) Do(f func(T) typed.Baz[T]) *MockBarFiveCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarFiveCall[T, R]) DoAndReturn(f func(T) typed.Baz[T]) *MockBarFiveCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Four indicates an expected call of Four.
func (mr *MockBarMockRecorder[T, R]) Four(arg0 any) *MockBarFourCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Four", reflect.TypeOf((*MockBar[T, R])(nil).Four), arg0)
	return &MockBarFourCall[T, R]{Call: call}
}

// MockBarFourCall wrap *gomock.Call
type MockBarFourCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarFourCall[T, R]) Return(arg0 typed.Foo[T, R]) *MockBarFourCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarFourCall[T, R]) Do(f func(T) typed.Foo[T, R]) *MockBarFourCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarFourCall[T, R]) DoAndReturn(f func(T) typed.Foo[T, R]) *MockBarFourCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Fourteen mocks base method.
func (m *MockBar[T, R]) Fourteen() (*typed.Foo[typed.StructType, typed.StructType2], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fourteen")
	ret0, _ := ret[0].(*typed.Foo[typed.StructType, typed.StructType2])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fourteen indicates an expected call of Fourteen.
func (mr *MockBarMockRecorder[T, R]) Fourteen() *MockBarFourteenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fourteen", reflect.TypeOf((*MockBar[T, R])(nil).Fourteen))
	return &MockBarFourteenCall[T, R]{Call: call}
}

// MockBarFourteenCall wrap *gomock.Call
type MockBarFourteenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarFourteenCall[T, R]) Return(arg0 *typed.Foo[typed.StructType, typed.StructType2], arg1 error) *MockBarFourteenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarFourteenCall[T, R]) Do(f func() (*typed.Foo[typed.StructType, typed.StructType2], error)) *MockBarFourteenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarFourteenCall[T, R]) DoAndReturn(f func() (*typed.Foo[typed.StructType, typed.StructType2], error)) *MockBarFourteenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Nine indicates an expected call of Nine.
func (mr *MockBarMockRecorder[T, R]) Nine(arg0 any) *MockBarNineCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nine", reflect.TypeOf((*MockBar[T, R])(nil).Nine), arg0)
	return &MockBarNineCall[T, R]{Call: call}
}

// MockBarNineCall wrap *gomock.Call
type MockBarNineCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarNineCall[T, R]) Return() *MockBarNineCall[T, R] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarNineCall[T, R]) Do(f func(typed.Iface[T])) *MockBarNineCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarNineCall[T, R]) DoAndReturn(f func(typed.Iface[T])) *MockBarNineCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Nineteen mocks base method.
func (m *MockBar[T, R]) Nineteen() typed.AliasType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Nineteen")
	ret0, _ := ret[0].(typed.AliasType)
	return ret0
}

// Nineteen indicates an expected call of Nineteen.
func (mr *MockBarMockRecorder[T, R]) Nineteen() *MockBarNineteenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Nineteen", reflect.TypeOf((*MockBar[T, R])(nil).Nineteen))
	return &MockBarNineteenCall[T, R]{Call: call}
}

// MockBarNineteenCall wrap *gomock.Call
type MockBarNineteenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarNineteenCall[T, R]) Return(arg0 typed.AliasType) *MockBarNineteenCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarNineteenCall[T, R]) Do(f func() typed.AliasType) *MockBarNineteenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarNineteenCall[T, R]) DoAndReturn(f func() typed.AliasType) *MockBarNineteenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// One mocks base method.
func (m *MockBar[T, R]) 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 *MockBarMockRecorder[T, R]) One(arg0 any) *MockBarOneCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "One", reflect.TypeOf((*MockBar[T, R])(nil).One), arg0)
	return &MockBarOneCall[T, R]{Call: call}
}

// MockBarOneCall wrap *gomock.Call
type MockBarOneCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarOneCall[T, R]) Return(arg0 string) *MockBarOneCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarOneCall[T, R]) Do(f func(string) string) *MockBarOneCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarOneCall[T, R]) DoAndReturn(f func(string) string) *MockBarOneCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Seven indicates an expected call of Seven.
func (mr *MockBarMockRecorder[T, R]) Seven(arg0 any) *MockBarSevenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seven", reflect.TypeOf((*MockBar[T, R])(nil).Seven), arg0)
	return &MockBarSevenCall[T, R]{Call: call}
}

// MockBarSevenCall wrap *gomock.Call
type MockBarSevenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarSevenCall[T, R]) Return(arg0 other.One[T]) *MockBarSevenCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarSevenCall[T, R]) Do(f func(T) other.One[T]) *MockBarSevenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarSevenCall[T, R]) DoAndReturn(f func(T) other.One[T]) *MockBarSevenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Seventeen mocks base method.
func (m *MockBar[T, R]) Seventeen() (*typed.Foo[other.Three, other.Four], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Seventeen")
	ret0, _ := ret[0].(*typed.Foo[other.Three, other.Four])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Seventeen indicates an expected call of Seventeen.
func (mr *MockBarMockRecorder[T, R]) Seventeen() *MockBarSeventeenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seventeen", reflect.TypeOf((*MockBar[T, R])(nil).Seventeen))
	return &MockBarSeventeenCall[T, R]{Call: call}
}

// MockBarSeventeenCall wrap *gomock.Call
type MockBarSeventeenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarSeventeenCall[T, R]) Return(arg0 *typed.Foo[other.Three, other.Four], arg1 error) *MockBarSeventeenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarSeventeenCall[T, R]) Do(f func() (*typed.Foo[other.Three, other.Four], error)) *MockBarSeventeenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarSeventeenCall[T, R]) DoAndReturn(f func() (*typed.Foo[other.Three, other.Four], error)) *MockBarSeventeenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Six indicates an expected call of Six.
func (mr *MockBarMockRecorder[T, R]) Six(arg0 any) *MockBarSixCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Six", reflect.TypeOf((*MockBar[T, R])(nil).Six), arg0)
	return &MockBarSixCall[T, R]{Call: call}
}

// MockBarSixCall wrap *gomock.Call
type MockBarSixCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarSixCall[T, R]) Return(arg0 *typed.Baz[T]) *MockBarSixCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarSixCall[T, R]) Do(f func(T) *typed.Baz[T]) *MockBarSixCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarSixCall[T, R]) DoAndReturn(f func(T) *typed.Baz[T]) *MockBarSixCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Sixteen mocks base method.
func (m *MockBar[T, R]) Sixteen() (typed.Baz[other.Three], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Sixteen")
	ret0, _ := ret[0].(typed.Baz[other.Three])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Sixteen indicates an expected call of Sixteen.
func (mr *MockBarMockRecorder[T, R]) Sixteen() *MockBarSixteenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Sixteen", reflect.TypeOf((*MockBar[T, R])(nil).Sixteen))
	return &MockBarSixteenCall[T, R]{Call: call}
}

// MockBarSixteenCall wrap *gomock.Call
type MockBarSixteenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarSixteenCall[T, R]) Return(arg0 typed.Baz[other.Three], arg1 error) *MockBarSixteenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarSixteenCall[T, R]) Do(f func() (typed.Baz[other.Three], error)) *MockBarSixteenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarSixteenCall[T, R]) DoAndReturn(f func() (typed.Baz[other.Three], error)) *MockBarSixteenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Ten indicates an expected call of Ten.
func (mr *MockBarMockRecorder[T, R]) Ten(arg0 any) *MockBarTenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ten", reflect.TypeOf((*MockBar[T, R])(nil).Ten), arg0)
	return &MockBarTenCall[T, R]{Call: call}
}

// MockBarTenCall wrap *gomock.Call
type MockBarTenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarTenCall[T, R]) Return() *MockBarTenCall[T, R] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarTenCall[T, R]) Do(f func(*T)) *MockBarTenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarTenCall[T, R]) DoAndReturn(f func(*T)) *MockBarTenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Thirteen mocks base method.
func (m *MockBar[T, R]) Thirteen() (typed.Baz[typed.StructType], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Thirteen")
	ret0, _ := ret[0].(typed.Baz[typed.StructType])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Thirteen indicates an expected call of Thirteen.
func (mr *MockBarMockRecorder[T, R]) Thirteen() *MockBarThirteenCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Thirteen", reflect.TypeOf((*MockBar[T, R])(nil).Thirteen))
	return &MockBarThirteenCall[T, R]{Call: call}
}

// MockBarThirteenCall wrap *gomock.Call
type MockBarThirteenCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarThirteenCall[T, R]) Return(arg0 typed.Baz[typed.StructType], arg1 error) *MockBarThirteenCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarThirteenCall[T, R]) Do(f func() (typed.Baz[typed.StructType], error)) *MockBarThirteenCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarThirteenCall[T, R]) DoAndReturn(f func() (typed.Baz[typed.StructType], error)) *MockBarThirteenCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Three indicates an expected call of Three.
func (mr *MockBarMockRecorder[T, R]) Three(arg0 any) *MockBarThreeCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Three", reflect.TypeOf((*MockBar[T, R])(nil).Three), arg0)
	return &MockBarThreeCall[T, R]{Call: call}
}

// MockBarThreeCall wrap *gomock.Call
type MockBarThreeCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarThreeCall[T, R]) Return(arg0 R) *MockBarThreeCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarThreeCall[T, R]) Do(f func(T) R) *MockBarThreeCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarThreeCall[T, R]) DoAndReturn(f func(T) R) *MockBarThreeCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Twelve mocks base method.
func (m *MockBar[T, R]) Twelve() (*other.Two[T, R], error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Twelve")
	ret0, _ := ret[0].(*other.Two[T, R])
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Twelve indicates an expected call of Twelve.
func (mr *MockBarMockRecorder[T, R]) Twelve() *MockBarTwelveCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Twelve", reflect.TypeOf((*MockBar[T, R])(nil).Twelve))
	return &MockBarTwelveCall[T, R]{Call: call}
}

// MockBarTwelveCall wrap *gomock.Call
type MockBarTwelveCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarTwelveCall[T, R]) Return(arg0 *other.Two[T, R], arg1 error) *MockBarTwelveCall[T, R] {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarTwelveCall[T, R]) Do(f func() (*other.Two[T, R], error)) *MockBarTwelveCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarTwelveCall[T, R]) DoAndReturn(f func() (*other.Two[T, R], error)) *MockBarTwelveCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Two mocks base method.
func (m *MockBar[T, R]) Two(arg0 T) 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 *MockBarMockRecorder[T, R]) Two(arg0 any) *MockBarTwoCall[T, R] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Two", reflect.TypeOf((*MockBar[T, R])(nil).Two), arg0)
	return &MockBarTwoCall[T, R]{Call: call}
}

// MockBarTwoCall wrap *gomock.Call
type MockBarTwoCall[T any, R any] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarTwoCall[T, R]) Return(arg0 string) *MockBarTwoCall[T, R] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarTwoCall[T, R]) Do(f func(T) string) *MockBarTwoCall[T, R] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarTwoCall[T, R]) DoAndReturn(f func(T) string) *MockBarTwoCall[T, R] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
