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

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

import (
	context "context"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
	runtime "k8s.io/apimachinery/pkg/runtime"
)

// MockwatchFactory is a mock of watchFactory interface.
type MockwatchFactory struct {
	ctrl     *gomock.Controller
	recorder *MockwatchFactoryMockRecorder
	isgomock struct{}
}

// MockwatchFactoryMockRecorder is the mock recorder for MockwatchFactory.
type MockwatchFactoryMockRecorder struct {
	mock *MockwatchFactory
}

// NewMockwatchFactory creates a new mock instance.
func NewMockwatchFactory(ctrl *gomock.Controller) *MockwatchFactory {
	mock := &MockwatchFactory{ctrl: ctrl}
	mock.recorder = &MockwatchFactoryMockRecorder{mock}
	return mock
}

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

// new mocks base method.
func (m *MockwatchFactory) new(watchRequest *WatchRequest, sender watchResponseSender) watchInterface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "new", watchRequest, sender)
	ret0, _ := ret[0].(watchInterface)
	return ret0
}

// new indicates an expected call of new.
func (mr *MockwatchFactoryMockRecorder) new(watchRequest, sender any) *MockwatchFactorynewCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "new", reflect.TypeOf((*MockwatchFactory)(nil).new), watchRequest, sender)
	return &MockwatchFactorynewCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockwatchFactorynewCall) Return(arg0 watchInterface) *MockwatchFactorynewCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockwatchFactorynewCall) Do(f func(*WatchRequest, watchResponseSender) watchInterface) *MockwatchFactorynewCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockwatchFactorynewCall) DoAndReturn(f func(*WatchRequest, watchResponseSender) watchInterface) *MockwatchFactorynewCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// MockwatchResponseSender is a mock of watchResponseSender interface.
type MockwatchResponseSender struct {
	ctrl     *gomock.Controller
	recorder *MockwatchResponseSenderMockRecorder
	isgomock struct{}
}

// MockwatchResponseSenderMockRecorder is the mock recorder for MockwatchResponseSender.
type MockwatchResponseSenderMockRecorder struct {
	mock *MockwatchResponseSender
}

// NewMockwatchResponseSender creates a new mock instance.
func NewMockwatchResponseSender(ctrl *gomock.Controller) *MockwatchResponseSender {
	mock := &MockwatchResponseSender{ctrl: ctrl}
	mock.recorder = &MockwatchResponseSenderMockRecorder{mock}
	return mock
}

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

// sendError mocks base method.
func (m *MockwatchResponseSender) sendError(watchID, errorType string, err error, obj runtime.Object) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "sendError", watchID, errorType, err, obj)
}

// sendError indicates an expected call of sendError.
func (mr *MockwatchResponseSenderMockRecorder) sendError(watchID, errorType, err, obj any) *MockwatchResponseSendersendErrorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "sendError", reflect.TypeOf((*MockwatchResponseSender)(nil).sendError), watchID, errorType, err, obj)
	return &MockwatchResponseSendersendErrorCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockwatchResponseSendersendErrorCall) Do(f func(string, string, error, runtime.Object)) *MockwatchResponseSendersendErrorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockwatchResponseSendersendErrorCall) DoAndReturn(f func(string, string, error, runtime.Object)) *MockwatchResponseSendersendErrorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// sendEvent mocks base method.
func (m *MockwatchResponseSender) sendEvent(watchID string, e *k8sWatchEvent) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "sendEvent", watchID, e)
}

// sendEvent indicates an expected call of sendEvent.
func (mr *MockwatchResponseSenderMockRecorder) sendEvent(watchID, e any) *MockwatchResponseSendersendEventCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "sendEvent", reflect.TypeOf((*MockwatchResponseSender)(nil).sendEvent), watchID, e)
	return &MockwatchResponseSendersendEventCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockwatchResponseSendersendEventCall) Do(f func(string, *k8sWatchEvent)) *MockwatchResponseSendersendEventCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockwatchResponseSendersendEventCall) DoAndReturn(f func(string, *k8sWatchEvent)) *MockwatchResponseSendersendEventCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// sendStop mocks base method.
func (m *MockwatchResponseSender) sendStop(watchID string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "sendStop", watchID)
}

// sendStop indicates an expected call of sendStop.
func (mr *MockwatchResponseSenderMockRecorder) sendStop(watchID any) *MockwatchResponseSendersendStopCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "sendStop", reflect.TypeOf((*MockwatchResponseSender)(nil).sendStop), watchID)
	return &MockwatchResponseSendersendStopCall{Call: call}
}

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

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

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

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

// MockwatchInterface is a mock of watchInterface interface.
type MockwatchInterface struct {
	ctrl     *gomock.Controller
	recorder *MockwatchInterfaceMockRecorder
	isgomock struct{}
}

// MockwatchInterfaceMockRecorder is the mock recorder for MockwatchInterface.
type MockwatchInterfaceMockRecorder struct {
	mock *MockwatchInterface
}

// NewMockwatchInterface creates a new mock instance.
func NewMockwatchInterface(ctrl *gomock.Controller) *MockwatchInterface {
	mock := &MockwatchInterface{ctrl: ctrl}
	mock.recorder = &MockwatchInterfaceMockRecorder{mock}
	return mock
}

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

// handle mocks base method.
func (m *MockwatchInterface) handle(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "handle", arg0)
}

// handle indicates an expected call of handle.
func (mr *MockwatchInterfaceMockRecorder) handle(arg0 any) *MockwatchInterfacehandleCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "handle", reflect.TypeOf((*MockwatchInterface)(nil).handle), arg0)
	return &MockwatchInterfacehandleCall{Call: call}
}

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

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

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

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