func (mr *MockPaintStatusWriterMockRecorder) PatchPaintStatus(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchPaintStatus", reflect.TypeOf((*MockPaintStatusWriter)(nil).PatchPaintStatus), varargs...)
}
PatchPaintStatus indicates an expected call of PatchPaintStatus
package mock_v1
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	v1 "github.com/solo-io/skv2/codegen/test/api/things.test.io/v1"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)
type MockMulticlusterClientset struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterClientsetMockRecorder
}
type MockMulticlusterClientsetMockRecorder struct {
	mock *MockMulticlusterClientset
}
func NewMockMulticlusterClientset(ctrl *gomock.Controller) *MockMulticlusterClientset {
	mock := &MockMulticlusterClientset{ctrl: ctrl}
	mock.recorder = &MockMulticlusterClientsetMockRecorder{mock}
	return mock
}
func (m *MockMulticlusterClientset) EXPECT() *MockMulticlusterClientsetMockRecorder {
	return m.recorder
}
func (m *MockMulticlusterClientset) Cluster(cluster string) (v1.Clientset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cluster", cluster)
	ret0, _ := ret[0].(v1.Clientset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMulticlusterClientsetMockRecorder) Cluster(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cluster", reflect.TypeOf((*MockMulticlusterClientset)(nil).Cluster), cluster)
}
type MockClientset struct {
	ctrl     *gomock.Controller
	recorder *MockClientsetMockRecorder
}
type MockClientsetMockRecorder struct {
	mock *MockClientset
}
func NewMockClientset(ctrl *gomock.Controller) *MockClientset {
	mock := &MockClientset{ctrl: ctrl}
	mock.recorder = &MockClientsetMockRecorder{mock}
	return mock
}
func (m *MockClientset) EXPECT() *MockClientsetMockRecorder {
	return m.recorder
}
func (m *MockClientset) Paints() v1.PaintClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Paints")
	ret0, _ := ret[0].(v1.PaintClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) Paints() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Paints", reflect.TypeOf((*MockClientset)(nil).Paints))
}
func (m *MockClientset) ClusterResources() v1.ClusterResourceClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ClusterResources")
	ret0, _ := ret[0].(v1.ClusterResourceClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) ClusterResources() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ClusterResources", reflect.TypeOf((*MockClientset)(nil).ClusterResources))
}
type MockPaintReader struct {
	ctrl     *gomock.Controller
	recorder *MockPaintReaderMockRecorder
}
type MockPaintReaderMockRecorder struct {
	mock *MockPaintReader
}
func NewMockPaintReader(ctrl *gomock.Controller) *MockPaintReader {
	mock := &MockPaintReader{ctrl: ctrl}
	mock.recorder = &MockPaintReaderMockRecorder{mock}
	return mock
}
func (m *MockPaintReader) EXPECT() *MockPaintReaderMockRecorder {
	return m.recorder
}
func (m *MockPaintReader) GetPaint(ctx context.Context, key client.ObjectKey) (*v1.Paint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPaint", ctx, key)
	ret0, _ := ret[0].(*v1.Paint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPaintReaderMockRecorder) GetPaint(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPaint", reflect.TypeOf((*MockPaintReader)(nil).GetPaint), ctx, key)
}
func (m *MockPaintReader) ListPaint(ctx context.Context, opts ...client.ListOption) (*v1.PaintList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListPaint", varargs...)
	ret0, _ := ret[0].(*v1.PaintList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockPaintReaderMockRecorder) ListPaint(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPaint", reflect.TypeOf((*MockPaintReader)(nil).ListPaint), varargs...)
}
type MockPaintWriter struct {
	ctrl     *gomock.Controller
	recorder *MockPaintWriterMockRecorder
}
type MockPaintWriterMockRecorder struct {
	mock *MockPaintWriter
}
func NewMockPaintWriter(ctrl *gomock.Controller) *MockPaintWriter {
	mock := &MockPaintWriter{ctrl: ctrl}
	mock.recorder = &MockPaintWriterMockRecorder{mock}
	return mock
}
func (m *MockPaintWriter) EXPECT() *MockPaintWriterMockRecorder {
	return m.recorder
}
func (m *MockPaintWriter) CreatePaint(ctx context.Context, obj *v1.Paint, opts ...client.CreateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreatePaint", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintWriterMockRecorder) CreatePaint(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePaint", reflect.TypeOf((*MockPaintWriter)(nil).CreatePaint), varargs...)
}
func (m *MockPaintWriter) DeletePaint(ctx context.Context, key client.ObjectKey, opts ...client.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeletePaint", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintWriterMockRecorder) DeletePaint(ctx, key interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePaint", reflect.TypeOf((*MockPaintWriter)(nil).DeletePaint), varargs...)
}
func (m *MockPaintWriter) UpdatePaint(ctx context.Context, obj *v1.Paint, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePaint", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintWriterMockRecorder) UpdatePaint(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePaint", reflect.TypeOf((*MockPaintWriter)(nil).UpdatePaint), varargs...)
}
func (m *MockPaintWriter) PatchPaint(ctx context.Context, obj *v1.Paint, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchPaint", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintWriterMockRecorder) PatchPaint(ctx, obj, patch interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj, patch}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchPaint", reflect.TypeOf((*MockPaintWriter)(nil).PatchPaint), varargs...)
}
func (m *MockPaintWriter) DeleteAllOfPaint(ctx context.Context, opts ...client.DeleteAllOfOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAllOfPaint", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintWriterMockRecorder) DeleteAllOfPaint(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfPaint", reflect.TypeOf((*MockPaintWriter)(nil).DeleteAllOfPaint), varargs...)
}
func (m *MockPaintWriter) UpsertPaint(ctx context.Context, obj *v1.Paint, transitionFuncs ...v1.PaintTransitionFunction) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range transitionFuncs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertPaint", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintWriterMockRecorder) UpsertPaint(ctx, obj interface{}, transitionFuncs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, transitionFuncs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertPaint", reflect.TypeOf((*MockPaintWriter)(nil).UpsertPaint), varargs...)
}
type MockPaintStatusWriter struct {
	ctrl     *gomock.Controller
	recorder *MockPaintStatusWriterMockRecorder
}
type MockPaintStatusWriterMockRecorder struct {
	mock *MockPaintStatusWriter
}
func NewMockPaintStatusWriter(ctrl *gomock.Controller) *MockPaintStatusWriter {
	mock := &MockPaintStatusWriter{ctrl: ctrl}
	mock.recorder = &MockPaintStatusWriterMockRecorder{mock}
	return mock
}
func (m *MockPaintStatusWriter) EXPECT() *MockPaintStatusWriterMockRecorder {
	return m.recorder
}
func (m *MockPaintStatusWriter) UpdatePaintStatus(ctx context.Context, obj *v1.Paint, opts ...client.UpdateOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdatePaintStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockPaintStatusWriterMockRecorder) UpdatePaintStatus(ctx, obj interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, obj}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePaintStatus", reflect.TypeOf((*MockPaintStatusWriter)(nil).UpdatePaintStatus), varargs...)
}
func (m *MockPaintStatusWriter) PatchPaintStatus(ctx context.Context, obj *v1.Paint, patch client.Patch, opts ...client.PatchOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj, patch}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PatchPaintStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}