func NewMockClusterResourceReconcileLoop(ctrl *gomock.Controller) *MockClusterResourceReconcileLoop {
	mock := &MockClusterResourceReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockClusterResourceReconcileLoopMockRecorder{mock}
	return mock
}
NewMockClusterResourceReconcileLoop creates a new mock instance
package mock_controller
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	v1 "github.com/solo-io/skv2/codegen/test/api/things.test.io/v1"
	controller "github.com/solo-io/skv2/codegen/test/api/things.test.io/v1/controller"
	reconcile "github.com/solo-io/skv2/pkg/reconcile"
	predicate "sigs.k8s.io/controller-runtime/pkg/predicate"
)
type MockPaintReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockPaintReconcilerMockRecorder
}
type MockPaintReconcilerMockRecorder struct {
	mock *MockPaintReconciler
}
func NewMockPaintReconciler(ctrl *gomock.Controller) *MockPaintReconciler {
	mock := &MockPaintReconciler{ctrl: ctrl}
	mock.recorder = &MockPaintReconcilerMockRecorder{mock}
	return mock
}
func (m *MockPaintReconciler) EXPECT() *MockPaintReconcilerMockRecorder {
	return m.recorder
}
func (m *MockPaintReconciler) ReconcilePaint(obj *v1.Paint) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcilePaint", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPaintReconcilerMockRecorder) ReconcilePaint(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcilePaint", reflect.TypeOf((*MockPaintReconciler)(nil).ReconcilePaint), obj)
}
type MockPaintDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockPaintDeletionReconcilerMockRecorder
}
type MockPaintDeletionReconcilerMockRecorder struct {
	mock *MockPaintDeletionReconciler
}
func NewMockPaintDeletionReconciler(ctrl *gomock.Controller) *MockPaintDeletionReconciler {
	mock := &MockPaintDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockPaintDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockPaintDeletionReconciler) EXPECT() *MockPaintDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockPaintDeletionReconciler) ReconcilePaintDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcilePaintDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintDeletionReconcilerMockRecorder) ReconcilePaintDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcilePaintDeletion", reflect.TypeOf((*MockPaintDeletionReconciler)(nil).ReconcilePaintDeletion), req)
}
type MockPaintFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockPaintFinalizerMockRecorder
}
type MockPaintFinalizerMockRecorder struct {
	mock *MockPaintFinalizer
}
func NewMockPaintFinalizer(ctrl *gomock.Controller) *MockPaintFinalizer {
	mock := &MockPaintFinalizer{ctrl: ctrl}
	mock.recorder = &MockPaintFinalizerMockRecorder{mock}
	return mock
}
func (m *MockPaintFinalizer) EXPECT() *MockPaintFinalizerMockRecorder {
	return m.recorder
}
func (m *MockPaintFinalizer) ReconcilePaint(obj *v1.Paint) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcilePaint", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPaintFinalizerMockRecorder) ReconcilePaint(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcilePaint", reflect.TypeOf((*MockPaintFinalizer)(nil).ReconcilePaint), obj)
}
func (m *MockPaintFinalizer) PaintFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PaintFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockPaintFinalizerMockRecorder) PaintFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PaintFinalizerName", reflect.TypeOf((*MockPaintFinalizer)(nil).PaintFinalizerName))
}
func (m *MockPaintFinalizer) FinalizePaint(obj *v1.Paint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizePaint", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintFinalizerMockRecorder) FinalizePaint(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizePaint", reflect.TypeOf((*MockPaintFinalizer)(nil).FinalizePaint), obj)
}
type MockPaintReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockPaintReconcileLoopMockRecorder
}
type MockPaintReconcileLoopMockRecorder struct {
	mock *MockPaintReconcileLoop
}
func NewMockPaintReconcileLoop(ctrl *gomock.Controller) *MockPaintReconcileLoop {
	mock := &MockPaintReconcileLoop{ctrl: ctrl}
	mock.recorder = &MockPaintReconcileLoopMockRecorder{mock}
	return mock
}
func (m *MockPaintReconcileLoop) EXPECT() *MockPaintReconcileLoopMockRecorder {
	return m.recorder
}
func (m *MockPaintReconcileLoop) RunPaintReconciler(ctx context.Context, rec controller.PaintReconciler, predicates ...predicate.Predicate) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, rec}
	for _, a := range predicates {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunPaintReconciler", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintReconcileLoopMockRecorder) RunPaintReconciler(ctx, rec interface{}, predicates ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, rec}, predicates...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunPaintReconciler", reflect.TypeOf((*MockPaintReconcileLoop)(nil).RunPaintReconciler), varargs...)
}
type MockClusterResourceReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterResourceReconcilerMockRecorder
}
type MockClusterResourceReconcilerMockRecorder struct {
	mock *MockClusterResourceReconciler
}
func NewMockClusterResourceReconciler(ctrl *gomock.Controller) *MockClusterResourceReconciler {
	mock := &MockClusterResourceReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterResourceReconcilerMockRecorder{mock}
	return mock
}
func (m *MockClusterResourceReconciler) EXPECT() *MockClusterResourceReconcilerMockRecorder {
	return m.recorder
}
func (m *MockClusterResourceReconciler) ReconcileClusterResource(obj *v1.ClusterResource) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterResource", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockClusterResourceReconcilerMockRecorder) ReconcileClusterResource(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterResource", reflect.TypeOf((*MockClusterResourceReconciler)(nil).ReconcileClusterResource), obj)
}
type MockClusterResourceDeletionReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockClusterResourceDeletionReconcilerMockRecorder
}
type MockClusterResourceDeletionReconcilerMockRecorder struct {
	mock *MockClusterResourceDeletionReconciler
}
func NewMockClusterResourceDeletionReconciler(ctrl *gomock.Controller) *MockClusterResourceDeletionReconciler {
	mock := &MockClusterResourceDeletionReconciler{ctrl: ctrl}
	mock.recorder = &MockClusterResourceDeletionReconcilerMockRecorder{mock}
	return mock
}
func (m *MockClusterResourceDeletionReconciler) EXPECT() *MockClusterResourceDeletionReconcilerMockRecorder {
	return m.recorder
}
func (m *MockClusterResourceDeletionReconciler) ReconcileClusterResourceDeletion(req reconcile.Request) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterResourceDeletion", req)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterResourceDeletionReconcilerMockRecorder) ReconcileClusterResourceDeletion(req interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterResourceDeletion", reflect.TypeOf((*MockClusterResourceDeletionReconciler)(nil).ReconcileClusterResourceDeletion), req)
}
type MockClusterResourceFinalizer struct {
	ctrl     *gomock.Controller
	recorder *MockClusterResourceFinalizerMockRecorder
}
type MockClusterResourceFinalizerMockRecorder struct {
	mock *MockClusterResourceFinalizer
}
func NewMockClusterResourceFinalizer(ctrl *gomock.Controller) *MockClusterResourceFinalizer {
	mock := &MockClusterResourceFinalizer{ctrl: ctrl}
	mock.recorder = &MockClusterResourceFinalizerMockRecorder{mock}
	return mock
}
func (m *MockClusterResourceFinalizer) EXPECT() *MockClusterResourceFinalizerMockRecorder {
	return m.recorder
}
func (m *MockClusterResourceFinalizer) ReconcileClusterResource(obj *v1.ClusterResource) (reconcile.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileClusterResource", obj)
	ret0, _ := ret[0].(reconcile.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockClusterResourceFinalizerMockRecorder) ReconcileClusterResource(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileClusterResource", reflect.TypeOf((*MockClusterResourceFinalizer)(nil).ReconcileClusterResource), obj)
}
func (m *MockClusterResourceFinalizer) ClusterResourceFinalizerName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterResourceFinalizerName")
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockClusterResourceFinalizerMockRecorder) ClusterResourceFinalizerName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResourceFinalizerName", reflect.TypeOf((*MockClusterResourceFinalizer)(nil).ClusterResourceFinalizerName))
}
func (m *MockClusterResourceFinalizer) FinalizeClusterResource(obj *v1.ClusterResource) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizeClusterResource", obj)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockClusterResourceFinalizerMockRecorder) FinalizeClusterResource(obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizeClusterResource", reflect.TypeOf((*MockClusterResourceFinalizer)(nil).FinalizeClusterResource), obj)
}
type MockClusterResourceReconcileLoop struct {
	ctrl     *gomock.Controller
	recorder *MockClusterResourceReconcileLoopMockRecorder
}
type MockClusterResourceReconcileLoopMockRecorder struct {
	mock *MockClusterResourceReconcileLoop
}