// Code generated by MockGen. DO NOT EDIT.
// Source: go.uber.org/mock/mockgen/internal/tests/alias (interfaces: Fooer,FooerAlias,Barer,BarerAlias,Bazer,QuxerConsumer,QuuxerConsumer)
//
// Generated by this command:
//
//	mockgen -typed -package=mock -destination=mock/interfaces.go . Fooer,FooerAlias,Barer,BarerAlias,Bazer,QuxerConsumer,QuuxerConsumer
//

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

import (
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	alias "go.uber.org/mock/mockgen/internal/tests/alias"
	subpkg "go.uber.org/mock/mockgen/internal/tests/alias/subpkg"
)

// MockFooer is a mock of Fooer interface.
type MockFooer struct {
	ctrl     *gomock.Controller
	recorder *MockFooerMockRecorder
	isgomock struct{}
}

// MockFooerMockRecorder is the mock recorder for MockFooer.
type MockFooerMockRecorder struct {
	mock *MockFooer
}

// NewMockFooer creates a new mock instance.
func NewMockFooer(ctrl *gomock.Controller) *MockFooer {
	mock := &MockFooer{ctrl: ctrl}
	mock.recorder = &MockFooerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFooer) EXPECT() *MockFooerMockRecorder {
	return m.recorder
}

// Foo mocks base method.
func (m *MockFooer) Foo() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Foo")
}

// Foo indicates an expected call of Foo.
func (mr *MockFooerMockRecorder) Foo() *MockFooerFooCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Foo", reflect.TypeOf((*MockFooer)(nil).Foo))
	return &MockFooerFooCall{Call: call}
}

// MockFooerFooCall wrap *gomock.Call
type MockFooerFooCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFooerFooCall) Return() *MockFooerFooCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFooerFooCall) Do(f func()) *MockFooerFooCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFooerFooCall) DoAndReturn(f func()) *MockFooerFooCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockFooerAlias is a mock of FooerAlias interface.
type MockFooerAlias struct {
	ctrl     *gomock.Controller
	recorder *MockFooerAliasMockRecorder
	isgomock struct{}
}

// MockFooerAliasMockRecorder is the mock recorder for MockFooerAlias.
type MockFooerAliasMockRecorder struct {
	mock *MockFooerAlias
}

// NewMockFooerAlias creates a new mock instance.
func NewMockFooerAlias(ctrl *gomock.Controller) *MockFooerAlias {
	mock := &MockFooerAlias{ctrl: ctrl}
	mock.recorder = &MockFooerAliasMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockFooerAlias) EXPECT() *MockFooerAliasMockRecorder {
	return m.recorder
}

// Foo mocks base method.
func (m *MockFooerAlias) Foo() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Foo")
}

// Foo indicates an expected call of Foo.
func (mr *MockFooerAliasMockRecorder) Foo() *MockFooerAliasFooCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Foo", reflect.TypeOf((*MockFooerAlias)(nil).Foo))
	return &MockFooerAliasFooCall{Call: call}
}

// MockFooerAliasFooCall wrap *gomock.Call
type MockFooerAliasFooCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockFooerAliasFooCall) Return() *MockFooerAliasFooCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockFooerAliasFooCall) Do(f func()) *MockFooerAliasFooCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockFooerAliasFooCall) DoAndReturn(f func()) *MockFooerAliasFooCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockBarer is a mock of Barer interface.
type MockBarer struct {
	ctrl     *gomock.Controller
	recorder *MockBarerMockRecorder
	isgomock struct{}
}

// MockBarerMockRecorder is the mock recorder for MockBarer.
type MockBarerMockRecorder struct {
	mock *MockBarer
}

// NewMockBarer creates a new mock instance.
func NewMockBarer(ctrl *gomock.Controller) *MockBarer {
	mock := &MockBarer{ctrl: ctrl}
	mock.recorder = &MockBarerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBarer) EXPECT() *MockBarerMockRecorder {
	return m.recorder
}

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

// Bar indicates an expected call of Bar.
func (mr *MockBarerMockRecorder) Bar(arg0 any) *MockBarerBarCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bar", reflect.TypeOf((*MockBarer)(nil).Bar), arg0)
	return &MockBarerBarCall{Call: call}
}

// MockBarerBarCall wrap *gomock.Call
type MockBarerBarCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarerBarCall) Return(arg0 alias.FooerAlias) *MockBarerBarCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarerBarCall) Do(f func(alias.FooerAlias) alias.FooerAlias) *MockBarerBarCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarerBarCall) DoAndReturn(f func(alias.FooerAlias) alias.FooerAlias) *MockBarerBarCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockBarerAlias is a mock of BarerAlias interface.
type MockBarerAlias struct {
	ctrl     *gomock.Controller
	recorder *MockBarerAliasMockRecorder
	isgomock struct{}
}

// MockBarerAliasMockRecorder is the mock recorder for MockBarerAlias.
type MockBarerAliasMockRecorder struct {
	mock *MockBarerAlias
}

// NewMockBarerAlias creates a new mock instance.
func NewMockBarerAlias(ctrl *gomock.Controller) *MockBarerAlias {
	mock := &MockBarerAlias{ctrl: ctrl}
	mock.recorder = &MockBarerAliasMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBarerAlias) EXPECT() *MockBarerAliasMockRecorder {
	return m.recorder
}

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

// Bar indicates an expected call of Bar.
func (mr *MockBarerAliasMockRecorder) Bar(arg0 any) *MockBarerAliasBarCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bar", reflect.TypeOf((*MockBarerAlias)(nil).Bar), arg0)
	return &MockBarerAliasBarCall{Call: call}
}

// MockBarerAliasBarCall wrap *gomock.Call
type MockBarerAliasBarCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBarerAliasBarCall) Return(arg0 alias.FooerAlias) *MockBarerAliasBarCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBarerAliasBarCall) Do(f func(alias.FooerAlias) alias.FooerAlias) *MockBarerAliasBarCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBarerAliasBarCall) DoAndReturn(f func(alias.FooerAlias) alias.FooerAlias) *MockBarerAliasBarCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockBazer is a mock of Bazer interface.
type MockBazer struct {
	ctrl     *gomock.Controller
	recorder *MockBazerMockRecorder
	isgomock struct{}
}

// MockBazerMockRecorder is the mock recorder for MockBazer.
type MockBazerMockRecorder struct {
	mock *MockBazer
}

// NewMockBazer creates a new mock instance.
func NewMockBazer(ctrl *gomock.Controller) *MockBazer {
	mock := &MockBazer{ctrl: ctrl}
	mock.recorder = &MockBazerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBazer) EXPECT() *MockBazerMockRecorder {
	return m.recorder
}

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

// Baz indicates an expected call of Baz.
func (mr *MockBazerMockRecorder) Baz(arg0 any) *MockBazerBazCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Baz", reflect.TypeOf((*MockBazer)(nil).Baz), arg0)
	return &MockBazerBazCall{Call: call}
}

// MockBazerBazCall wrap *gomock.Call
type MockBazerBazCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBazerBazCall) Return(arg0 alias.Fooer) *MockBazerBazCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBazerBazCall) Do(f func(alias.Fooer) alias.Fooer) *MockBazerBazCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBazerBazCall) DoAndReturn(f func(alias.Fooer) alias.Fooer) *MockBazerBazCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockQuxerConsumer is a mock of QuxerConsumer interface.
type MockQuxerConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockQuxerConsumerMockRecorder
	isgomock struct{}
}

// MockQuxerConsumerMockRecorder is the mock recorder for MockQuxerConsumer.
type MockQuxerConsumerMockRecorder struct {
	mock *MockQuxerConsumer
}

// NewMockQuxerConsumer creates a new mock instance.
func NewMockQuxerConsumer(ctrl *gomock.Controller) *MockQuxerConsumer {
	mock := &MockQuxerConsumer{ctrl: ctrl}
	mock.recorder = &MockQuxerConsumerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockQuxerConsumer) EXPECT() *MockQuxerConsumerMockRecorder {
	return m.recorder
}

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

// Consume indicates an expected call of Consume.
func (mr *MockQuxerConsumerMockRecorder) Consume(arg0 any) *MockQuxerConsumerConsumeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Consume", reflect.TypeOf((*MockQuxerConsumer)(nil).Consume), arg0)
	return &MockQuxerConsumerConsumeCall{Call: call}
}

// MockQuxerConsumerConsumeCall wrap *gomock.Call
type MockQuxerConsumerConsumeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQuxerConsumerConsumeCall) Return(arg0 alias.QuxerAlias) *MockQuxerConsumerConsumeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQuxerConsumerConsumeCall) Do(f func(alias.QuxerAlias) alias.QuxerAlias) *MockQuxerConsumerConsumeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQuxerConsumerConsumeCall) DoAndReturn(f func(alias.QuxerAlias) alias.QuxerAlias) *MockQuxerConsumerConsumeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockQuuxerConsumer is a mock of QuuxerConsumer interface.
type MockQuuxerConsumer struct {
	ctrl     *gomock.Controller
	recorder *MockQuuxerConsumerMockRecorder
	isgomock struct{}
}

// MockQuuxerConsumerMockRecorder is the mock recorder for MockQuuxerConsumer.
type MockQuuxerConsumerMockRecorder struct {
	mock *MockQuuxerConsumer
}

// NewMockQuuxerConsumer creates a new mock instance.
func NewMockQuuxerConsumer(ctrl *gomock.Controller) *MockQuuxerConsumer {
	mock := &MockQuuxerConsumer{ctrl: ctrl}
	mock.recorder = &MockQuuxerConsumerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockQuuxerConsumer) EXPECT() *MockQuuxerConsumerMockRecorder {
	return m.recorder
}

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

// Consume indicates an expected call of Consume.
func (mr *MockQuuxerConsumerMockRecorder) Consume(arg0 any) *MockQuuxerConsumerConsumeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Consume", reflect.TypeOf((*MockQuuxerConsumer)(nil).Consume), arg0)
	return &MockQuuxerConsumerConsumeCall{Call: call}
}

// MockQuuxerConsumerConsumeCall wrap *gomock.Call
type MockQuuxerConsumerConsumeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockQuuxerConsumerConsumeCall) Return(arg0 subpkg.Quuxer) *MockQuuxerConsumerConsumeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockQuuxerConsumerConsumeCall) Do(f func(subpkg.Quuxer) subpkg.Quuxer) *MockQuuxerConsumerConsumeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockQuuxerConsumerConsumeCall) DoAndReturn(f func(subpkg.Quuxer) subpkg.Quuxer) *MockQuuxerConsumerConsumeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
