func (mr *MockServiceAccountClientMockRecorder) DeleteServiceAccount(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, "DeleteServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).DeleteServiceAccount), varargs...)
}
DeleteServiceAccount indicates an expected call of DeleteServiceAccount
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...)
}
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
}
func (mr *MockSecretStatusWriterMockRecorder) PatchSecretStatus(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, "PatchSecretStatus", reflect.TypeOf((*MockSecretStatusWriter)(nil).PatchSecretStatus), varargs...)
}
type MockSecretClient struct {
	ctrl     *gomock.Controller
	recorder *MockSecretClientMockRecorder
}
type MockSecretClientMockRecorder struct {
	mock *MockSecretClient
}
func NewMockSecretClient(ctrl *gomock.Controller) *MockSecretClient {
	mock := &MockSecretClient{ctrl: ctrl}
	mock.recorder = &MockSecretClientMockRecorder{mock}
	return mock
}
func (m *MockSecretClient) EXPECT() *MockSecretClientMockRecorder {
	return m.recorder
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) GetSecret(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockSecretClient)(nil).GetSecret), ctx, key)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).ListSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).CreateSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).DeleteSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).UpdateSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).PatchSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).DeleteAllOfSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).UpsertSecret), varargs...)
}
func (m *MockSecretClient) 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 *MockSecretClientMockRecorder) 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((*MockSecretClient)(nil).UpdateSecretStatus), varargs...)
}
func (m *MockSecretClient) 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
}
func (mr *MockSecretClientMockRecorder) PatchSecretStatus(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, "PatchSecretStatus", reflect.TypeOf((*MockSecretClient)(nil).PatchSecretStatus), varargs...)
}
type MockMulticlusterSecretClient struct {
	ctrl     *gomock.Controller
	recorder *MockMulticlusterSecretClientMockRecorder
}
type MockMulticlusterSecretClientMockRecorder struct {
	mock *MockMulticlusterSecretClient
}
func NewMockMulticlusterSecretClient(ctrl *gomock.Controller) *MockMulticlusterSecretClient {
	mock := &MockMulticlusterSecretClient{ctrl: ctrl}
	mock.recorder = &MockMulticlusterSecretClientMockRecorder{mock}
	return mock
}
func (m *MockMulticlusterSecretClient) EXPECT() *MockMulticlusterSecretClientMockRecorder {
	return m.recorder
}
func (m *MockMulticlusterSecretClient) Cluster(cluster string) (v1.SecretClient, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Cluster", cluster)
	ret0, _ := ret[0].(v1.SecretClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockMulticlusterSecretClientMockRecorder) Cluster(cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cluster", reflect.TypeOf((*MockMulticlusterSecretClient)(nil).Cluster), cluster)
}
type MockServiceAccountReader struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountReaderMockRecorder
}
type MockServiceAccountReaderMockRecorder struct {
	mock *MockServiceAccountReader
}
func NewMockServiceAccountReader(ctrl *gomock.Controller) *MockServiceAccountReader {
	mock := &MockServiceAccountReader{ctrl: ctrl}
	mock.recorder = &MockServiceAccountReaderMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountReader) EXPECT() *MockServiceAccountReaderMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountReader) GetServiceAccount(ctx context.Context, key client.ObjectKey) (*v10.ServiceAccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceAccount", ctx, key)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockServiceAccountReaderMockRecorder) GetServiceAccount(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceAccount", reflect.TypeOf((*MockServiceAccountReader)(nil).GetServiceAccount), ctx, key)
}
func (m *MockServiceAccountReader) ListServiceAccount(ctx context.Context, opts ...client.ListOption) (*v10.ServiceAccountList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListServiceAccount", varargs...)
	ret0, _ := ret[0].(*v10.ServiceAccountList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockServiceAccountReaderMockRecorder) ListServiceAccount(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceAccount", reflect.TypeOf((*MockServiceAccountReader)(nil).ListServiceAccount), varargs...)
}
type MockServiceAccountWriter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountWriterMockRecorder
}
type MockServiceAccountWriterMockRecorder struct {
	mock *MockServiceAccountWriter
}
func NewMockServiceAccountWriter(ctrl *gomock.Controller) *MockServiceAccountWriter {
	mock := &MockServiceAccountWriter{ctrl: ctrl}
	mock.recorder = &MockServiceAccountWriterMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountWriter) EXPECT() *MockServiceAccountWriterMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountWriter) CreateServiceAccount(ctx context.Context, obj *v10.ServiceAccount, 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, "CreateServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountWriterMockRecorder) CreateServiceAccount(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, "CreateServiceAccount", reflect.TypeOf((*MockServiceAccountWriter)(nil).CreateServiceAccount), varargs...)
}
func (m *MockServiceAccountWriter) DeleteServiceAccount(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, "DeleteServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountWriterMockRecorder) DeleteServiceAccount(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, "DeleteServiceAccount", reflect.TypeOf((*MockServiceAccountWriter)(nil).DeleteServiceAccount), varargs...)
}
func (m *MockServiceAccountWriter) UpdateServiceAccount(ctx context.Context, obj *v10.ServiceAccount, 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, "UpdateServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountWriterMockRecorder) UpdateServiceAccount(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, "UpdateServiceAccount", reflect.TypeOf((*MockServiceAccountWriter)(nil).UpdateServiceAccount), varargs...)
}
func (m *MockServiceAccountWriter) PatchServiceAccount(ctx context.Context, obj *v10.ServiceAccount, 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, "PatchServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountWriterMockRecorder) PatchServiceAccount(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, "PatchServiceAccount", reflect.TypeOf((*MockServiceAccountWriter)(nil).PatchServiceAccount), varargs...)
}
func (m *MockServiceAccountWriter) DeleteAllOfServiceAccount(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, "DeleteAllOfServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountWriterMockRecorder) DeleteAllOfServiceAccount(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAllOfServiceAccount", reflect.TypeOf((*MockServiceAccountWriter)(nil).DeleteAllOfServiceAccount), varargs...)
}
func (m *MockServiceAccountWriter) UpsertServiceAccount(ctx context.Context, obj *v10.ServiceAccount, transitionFuncs ...v1.ServiceAccountTransitionFunction) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, obj}
	for _, a := range transitionFuncs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpsertServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountWriterMockRecorder) UpsertServiceAccount(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, "UpsertServiceAccount", reflect.TypeOf((*MockServiceAccountWriter)(nil).UpsertServiceAccount), varargs...)
}
type MockServiceAccountStatusWriter struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountStatusWriterMockRecorder
}
type MockServiceAccountStatusWriterMockRecorder struct {
	mock *MockServiceAccountStatusWriter
}
func NewMockServiceAccountStatusWriter(ctrl *gomock.Controller) *MockServiceAccountStatusWriter {
	mock := &MockServiceAccountStatusWriter{ctrl: ctrl}
	mock.recorder = &MockServiceAccountStatusWriterMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountStatusWriter) EXPECT() *MockServiceAccountStatusWriterMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountStatusWriter) UpdateServiceAccountStatus(ctx context.Context, obj *v10.ServiceAccount, 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, "UpdateServiceAccountStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountStatusWriterMockRecorder) UpdateServiceAccountStatus(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, "UpdateServiceAccountStatus", reflect.TypeOf((*MockServiceAccountStatusWriter)(nil).UpdateServiceAccountStatus), varargs...)
}
func (m *MockServiceAccountStatusWriter) PatchServiceAccountStatus(ctx context.Context, obj *v10.ServiceAccount, 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, "PatchServiceAccountStatus", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountStatusWriterMockRecorder) PatchServiceAccountStatus(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, "PatchServiceAccountStatus", reflect.TypeOf((*MockServiceAccountStatusWriter)(nil).PatchServiceAccountStatus), varargs...)
}
type MockServiceAccountClient struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountClientMockRecorder
}
type MockServiceAccountClientMockRecorder struct {
	mock *MockServiceAccountClient
}
func NewMockServiceAccountClient(ctrl *gomock.Controller) *MockServiceAccountClient {
	mock := &MockServiceAccountClient{ctrl: ctrl}
	mock.recorder = &MockServiceAccountClientMockRecorder{mock}
	return mock
}
func (m *MockServiceAccountClient) EXPECT() *MockServiceAccountClientMockRecorder {
	return m.recorder
}
func (m *MockServiceAccountClient) GetServiceAccount(ctx context.Context, key client.ObjectKey) (*v10.ServiceAccount, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServiceAccount", ctx, key)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockServiceAccountClientMockRecorder) GetServiceAccount(ctx, key interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).GetServiceAccount), ctx, key)
}
func (m *MockServiceAccountClient) ListServiceAccount(ctx context.Context, opts ...client.ListOption) (*v10.ServiceAccountList, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListServiceAccount", varargs...)
	ret0, _ := ret[0].(*v10.ServiceAccountList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockServiceAccountClientMockRecorder) ListServiceAccount(ctx interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).ListServiceAccount), varargs...)
}
func (m *MockServiceAccountClient) CreateServiceAccount(ctx context.Context, obj *v10.ServiceAccount, 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, "CreateServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockServiceAccountClientMockRecorder) CreateServiceAccount(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, "CreateServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).CreateServiceAccount), varargs...)
}
func (m *MockServiceAccountClient) DeleteServiceAccount(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, "DeleteServiceAccount", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}