func (m *MockSecretStatusWriter) PatchSecretStatus(ctx context.Context, obj *v10.Secret, 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, "PatchSecretStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
PatchSecretStatus mocks base method
package mock_v1
import (
	context "context"
	reflect "reflect"
	gomock "github.com/golang/mock/gomock"
	v1 "github.com/solo-io/skv2/pkg/multicluster/internal/k8s/core/v1"
	v10 "k8s.io/api/core/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) Secrets() v1.SecretClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Secrets")
	ret0, _ := ret[0].(v1.SecretClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) Secrets() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Secrets", reflect.TypeOf((*MockClientset)(nil).Secrets))
}
func (m *MockClientset) ServiceAccounts() v1.ServiceAccountClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ServiceAccounts")
	ret0, _ := ret[0].(v1.ServiceAccountClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) ServiceAccounts() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceAccounts", reflect.TypeOf((*MockClientset)(nil).ServiceAccounts))
}
func (m *MockClientset) Namespaces() v1.NamespaceClient {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Namespaces")
	ret0, _ := ret[0].(v1.NamespaceClient)
	return ret0
}
func (mr *MockClientsetMockRecorder) Namespaces() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Namespaces", reflect.TypeOf((*MockClientset)(nil).Namespaces))
}
type MockSecretReader struct {
	ctrl     *gomock.Controller
	recorder *MockSecretReaderMockRecorder
}
type MockSecretReaderMockRecorder struct {
	mock *MockSecretReader
}
func NewMockSecretReader(ctrl *gomock.Controller) *MockSecretReader {
	mock := &MockSecretReader{ctrl: ctrl}
	mock.recorder = &MockSecretReaderMockRecorder{mock}
	return mock
}
func (m *MockSecretReader) EXPECT() *MockSecretReaderMockRecorder {
	return m.recorder
}
func (m *MockSecretReader) GetSecret(ctx context.Context, key client.ObjectKey) (*v10.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecret", ctx, key)
	ret0, _ := ret[0].(*v10.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSecretReaderMockRecorder) GetSecret(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockSecretReader)(nil).GetSecret), ctx, key)
}
func (m *MockSecretReader) ListSecret(ctx context.Context, opts ...client.ListOption) (*v10.SecretList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSecret", varargs...)
	ret0, _ := ret[0].(*v10.SecretList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockSecretReaderMockRecorder) ListSecret(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecret", reflect.TypeOf((*MockSecretReader)(nil).ListSecret), varargs...)
}
type MockSecretWriter struct {
	ctrl     *gomock.Controller
	recorder *MockSecretWriterMockRecorder
}
type MockSecretWriterMockRecorder struct {
	mock *MockSecretWriter
}
func NewMockSecretWriter(ctrl *gomock.Controller) *MockSecretWriter {
	mock := &MockSecretWriter{ctrl: ctrl}
	mock.recorder = &MockSecretWriterMockRecorder{mock}
	return mock
}
func (m *MockSecretWriter) EXPECT() *MockSecretWriterMockRecorder {
	return m.recorder
}
func (m *MockSecretWriter) CreateSecret(ctx context.Context, obj *v10.Secret, 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, "CreateSecret", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretWriterMockRecorder) CreateSecret(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, "CreateSecret", reflect.TypeOf((*MockSecretWriter)(nil).CreateSecret), varargs...)
}
func (m *MockSecretWriter) DeleteSecret(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, "DeleteSecret", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretWriterMockRecorder) DeleteSecret(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, "DeleteSecret", reflect.TypeOf((*MockSecretWriter)(nil).DeleteSecret), varargs...)
}
func (m *MockSecretWriter) UpdateSecret(ctx context.Context, obj *v10.Secret, 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, "UpdateSecret", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretWriterMockRecorder) UpdateSecret(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, "UpdateSecret", reflect.TypeOf((*MockSecretWriter)(nil).UpdateSecret), varargs...)
}
func (m *MockSecretWriter) PatchSecret(ctx context.Context, obj *v10.Secret, 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, "PatchSecret", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretWriterMockRecorder) PatchSecret(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, "PatchSecret", reflect.TypeOf((*MockSecretWriter)(nil).PatchSecret), varargs...)
}
func (m *MockSecretWriter) DeleteAllOfSecret(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, "DeleteAllOfSecret", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretWriterMockRecorder) DeleteAllOfSecret(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfSecret", reflect.TypeOf((*MockSecretWriter)(nil).DeleteAllOfSecret), varargs...)
}
func (m *MockSecretWriter) UpsertSecret(ctx context.Context, obj *v10.Secret, transitionFuncs ...v1.SecretTransitionFunction) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range transitionFuncs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertSecret", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretWriterMockRecorder) UpsertSecret(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, "UpsertSecret", reflect.TypeOf((*MockSecretWriter)(nil).UpsertSecret), varargs...)
}
type MockSecretStatusWriter struct {
	ctrl     *gomock.Controller
	recorder *MockSecretStatusWriterMockRecorder
}
type MockSecretStatusWriterMockRecorder struct {
	mock *MockSecretStatusWriter
}
func NewMockSecretStatusWriter(ctrl *gomock.Controller) *MockSecretStatusWriter {
	mock := &MockSecretStatusWriter{ctrl: ctrl}
	mock.recorder = &MockSecretStatusWriterMockRecorder{mock}
	return mock
}
func (m *MockSecretStatusWriter) EXPECT() *MockSecretStatusWriterMockRecorder {
	return m.recorder
}
func (m *MockSecretStatusWriter) UpdateSecretStatus(ctx context.Context, obj *v10.Secret, 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, "UpdateSecretStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSecretStatusWriterMockRecorder) UpdateSecretStatus(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, "UpdateSecretStatus", reflect.TypeOf((*MockSecretStatusWriter)(nil).UpdateSecretStatus), varargs...)
}