odo/pkg/kclient/mock_Client.go

// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/kclient/interface.go

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

import (
	io "io"
	reflect "reflect"
	time "time"

	spec "github.com/go-openapi/spec"
	gomock "github.com/golang/mock/gomock"
	v1 "github.com/openshift/api/project/v1"
	v1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
	v1alpha10 "github.com/redhat-developer/service-binding-operator/apis/binding/v1alpha1"
	v1alpha3 "github.com/redhat-developer/service-binding-operator/apis/spec/v1alpha3"
	v10 "k8s.io/api/apps/v1"
	v11 "k8s.io/api/core/v1"
	meta "k8s.io/apimachinery/pkg/api/meta"
	v12 "k8s.io/apimachinery/pkg/apis/meta/v1"
	unstructured "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	discovery "k8s.io/client-go/discovery"
	dynamic "k8s.io/client-go/dynamic"
	kubernetes "k8s.io/client-go/kubernetes"
	rest "k8s.io/client-go/rest"
	clientcmd "k8s.io/client-go/tools/clientcmd"
)

// MockClientInterface is a mock of ClientInterface interface.
type MockClientInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientInterfaceMockRecorder
}

// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
type MockClientInterfaceMockRecorder struct {
	mock *MockClientInterface
}

// NewMockClientInterface creates a new mock instance.
func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
	mock := &MockClientInterface{ctrl: ctrl}
	mock.recorder = &MockClientInterfaceMockRecorder{mock}
	return mock
}

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

// ApplyDeployment mocks base method.
func (m *MockClientInterface) ApplyDeployment(deploy v10.Deployment) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyDeployment", deploy)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ApplyDeployment indicates an expected call of ApplyDeployment.
func (mr *MockClientInterfaceMockRecorder) ApplyDeployment(deploy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyDeployment", reflect.TypeOf((*MockClientInterface)(nil).ApplyDeployment), deploy)
}

// CollectEvents mocks base method.
func (m *MockClientInterface) CollectEvents(selector string, events map[string]v11.Event, quit <-chan int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectEvents", selector, events, quit)
}

// CollectEvents indicates an expected call of CollectEvents.
func (mr *MockClientInterfaceMockRecorder) CollectEvents(selector, events, quit interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CollectEvents", reflect.TypeOf((*MockClientInterface)(nil).CollectEvents), selector, events, quit)
}

// ConvertUnstructuredToResource mocks base method.
func (m *MockClientInterface) ConvertUnstructuredToResource(u unstructured.Unstructured, obj interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConvertUnstructuredToResource", u, obj)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConvertUnstructuredToResource indicates an expected call of ConvertUnstructuredToResource.
func (mr *MockClientInterfaceMockRecorder) ConvertUnstructuredToResource(u, obj interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConvertUnstructuredToResource", reflect.TypeOf((*MockClientInterface)(nil).ConvertUnstructuredToResource), u, obj)
}

// CreateDeployment mocks base method.
func (m *MockClientInterface) CreateDeployment(deploy v10.Deployment) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeployment", deploy)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDeployment indicates an expected call of CreateDeployment.
func (mr *MockClientInterfaceMockRecorder) CreateDeployment(deploy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeployment", reflect.TypeOf((*MockClientInterface)(nil).CreateDeployment), deploy)
}

// CreateDynamicResource mocks base method.
func (m *MockClientInterface) CreateDynamicResource(exampleCustomResource unstructured.Unstructured) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDynamicResource", exampleCustomResource)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateDynamicResource indicates an expected call of CreateDynamicResource.
func (mr *MockClientInterfaceMockRecorder) CreateDynamicResource(exampleCustomResource interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDynamicResource", reflect.TypeOf((*MockClientInterface)(nil).CreateDynamicResource), exampleCustomResource)
}

// CreateNamespace mocks base method.
func (m *MockClientInterface) CreateNamespace(name string) (*v11.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", name)
	ret0, _ := ret[0].(*v11.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNamespace indicates an expected call of CreateNamespace.
func (mr *MockClientInterfaceMockRecorder) CreateNamespace(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNamespace", reflect.TypeOf((*MockClientInterface)(nil).CreateNamespace), name)
}

// CreateNewProject mocks base method.
func (m *MockClientInterface) CreateNewProject(projectName string, wait bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNewProject", projectName, wait)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateNewProject indicates an expected call of CreateNewProject.
func (mr *MockClientInterfaceMockRecorder) CreateNewProject(projectName, wait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNewProject", reflect.TypeOf((*MockClientInterface)(nil).CreateNewProject), projectName, wait)
}

// CreatePVC mocks base method.
func (m *MockClientInterface) CreatePVC(pvc v11.PersistentVolumeClaim) (*v11.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePVC", pvc)
	ret0, _ := ret[0].(*v11.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePVC indicates an expected call of CreatePVC.
func (mr *MockClientInterfaceMockRecorder) CreatePVC(pvc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePVC", reflect.TypeOf((*MockClientInterface)(nil).CreatePVC), pvc)
}

// CreateSecret mocks base method.
func (m *MockClientInterface) CreateSecret(objectMeta v12.ObjectMeta, data map[string]string, ownerReference v12.OwnerReference) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecret", objectMeta, data, ownerReference)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateSecret indicates an expected call of CreateSecret.
func (mr *MockClientInterfaceMockRecorder) CreateSecret(objectMeta, data, ownerReference interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockClientInterface)(nil).CreateSecret), objectMeta, data, ownerReference)
}

// CreateSecrets mocks base method.
func (m *MockClientInterface) CreateSecrets(componentName string, commonObjectMeta v12.ObjectMeta, svc *v11.Service, ownerReference v12.OwnerReference) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSecrets", componentName, commonObjectMeta, svc, ownerReference)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateSecrets indicates an expected call of CreateSecrets.
func (mr *MockClientInterfaceMockRecorder) CreateSecrets(componentName, commonObjectMeta, svc, ownerReference interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecrets", reflect.TypeOf((*MockClientInterface)(nil).CreateSecrets), componentName, commonObjectMeta, svc, ownerReference)
}

// CreateService mocks base method.
func (m *MockClientInterface) CreateService(svc v11.Service) (*v11.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateService", svc)
	ret0, _ := ret[0].(*v11.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateService indicates an expected call of CreateService.
func (mr *MockClientInterfaceMockRecorder) CreateService(svc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateService", reflect.TypeOf((*MockClientInterface)(nil).CreateService), svc)
}

// CreateTLSSecret mocks base method.
func (m *MockClientInterface) CreateTLSSecret(tlsCertificate, tlsPrivKey []byte, objectMeta v12.ObjectMeta) (*v11.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTLSSecret", tlsCertificate, tlsPrivKey, objectMeta)
	ret0, _ := ret[0].(*v11.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateTLSSecret indicates an expected call of CreateTLSSecret.
func (mr *MockClientInterfaceMockRecorder) CreateTLSSecret(tlsCertificate, tlsPrivKey, objectMeta interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTLSSecret", reflect.TypeOf((*MockClientInterface)(nil).CreateTLSSecret), tlsCertificate, tlsPrivKey, objectMeta)
}

// DeleteDynamicResource mocks base method.
func (m *MockClientInterface) DeleteDynamicResource(name string, gvr schema.GroupVersionResource, wait bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDynamicResource", name, gvr, wait)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDynamicResource indicates an expected call of DeleteDynamicResource.
func (mr *MockClientInterfaceMockRecorder) DeleteDynamicResource(name, gvr, wait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDynamicResource", reflect.TypeOf((*MockClientInterface)(nil).DeleteDynamicResource), name, gvr, wait)
}

// DeleteNamespace mocks base method.
func (m *MockClientInterface) DeleteNamespace(name string, wait bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNamespace", name, wait)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNamespace indicates an expected call of DeleteNamespace.
func (mr *MockClientInterfaceMockRecorder) DeleteNamespace(name, wait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNamespace", reflect.TypeOf((*MockClientInterface)(nil).DeleteNamespace), name, wait)
}

// DeletePVC mocks base method.
func (m *MockClientInterface) DeletePVC(pvcName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePVC", pvcName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePVC indicates an expected call of DeletePVC.
func (mr *MockClientInterfaceMockRecorder) DeletePVC(pvcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePVC", reflect.TypeOf((*MockClientInterface)(nil).DeletePVC), pvcName)
}

// DeleteProject mocks base method.
func (m *MockClientInterface) DeleteProject(name string, wait bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProject", name, wait)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProject indicates an expected call of DeleteProject.
func (mr *MockClientInterfaceMockRecorder) DeleteProject(name, wait interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProject", reflect.TypeOf((*MockClientInterface)(nil).DeleteProject), name, wait)
}

// DeleteSecret mocks base method.
func (m *MockClientInterface) DeleteSecret(secretName, namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteSecret", secretName, namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSecret indicates an expected call of DeleteSecret.
func (mr *MockClientInterfaceMockRecorder) DeleteSecret(secretName, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockClientInterface)(nil).DeleteSecret), secretName, namespace)
}

// DeleteService mocks base method.
func (m *MockClientInterface) DeleteService(serviceName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteService", serviceName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteService indicates an expected call of DeleteService.
func (mr *MockClientInterfaceMockRecorder) DeleteService(serviceName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockClientInterface)(nil).DeleteService), serviceName)
}

// ExecCMDInContainer mocks base method.
func (m *MockClientInterface) ExecCMDInContainer(containerName, podName string, cmd []string, stdout, stderr io.Writer, stdin io.Reader, tty bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExecCMDInContainer", containerName, podName, cmd, stdout, stderr, stdin, tty)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExecCMDInContainer indicates an expected call of ExecCMDInContainer.
func (mr *MockClientInterfaceMockRecorder) ExecCMDInContainer(containerName, podName, cmd, stdout, stderr, stdin, tty interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecCMDInContainer", reflect.TypeOf((*MockClientInterface)(nil).ExecCMDInContainer), containerName, podName, cmd, stdout, stderr, stdin, tty)
}

// ExtractProjectToComponent mocks base method.
func (m *MockClientInterface) ExtractProjectToComponent(containerName, podName, targetPath string, stdin io.Reader) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExtractProjectToComponent", containerName, podName, targetPath, stdin)
	ret0, _ := ret[0].(error)
	return ret0
}

// ExtractProjectToComponent indicates an expected call of ExtractProjectToComponent.
func (mr *MockClientInterfaceMockRecorder) ExtractProjectToComponent(containerName, podName, targetPath, stdin interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExtractProjectToComponent", reflect.TypeOf((*MockClientInterface)(nil).ExtractProjectToComponent), containerName, podName, targetPath, stdin)
}

// GeneratePortForwardReq mocks base method.
func (m *MockClientInterface) GeneratePortForwardReq(podName string) *rest.Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GeneratePortForwardReq", podName)
	ret0, _ := ret[0].(*rest.Request)
	return ret0
}

// GeneratePortForwardReq indicates an expected call of GeneratePortForwardReq.
func (mr *MockClientInterfaceMockRecorder) GeneratePortForwardReq(podName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GeneratePortForwardReq", reflect.TypeOf((*MockClientInterface)(nil).GeneratePortForwardReq), podName)
}

// GetAllPodsInNamespace mocks base method.
func (m *MockClientInterface) GetAllPodsInNamespace() (*v11.PodList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllPodsInNamespace")
	ret0, _ := ret[0].(*v11.PodList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllPodsInNamespace indicates an expected call of GetAllPodsInNamespace.
func (mr *MockClientInterfaceMockRecorder) GetAllPodsInNamespace() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllPodsInNamespace", reflect.TypeOf((*MockClientInterface)(nil).GetAllPodsInNamespace))
}

// GetAllResourcesFromSelector mocks base method.
func (m *MockClientInterface) GetAllResourcesFromSelector(selector, ns string) ([]unstructured.Unstructured, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllResourcesFromSelector", selector, ns)
	ret0, _ := ret[0].([]unstructured.Unstructured)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllResourcesFromSelector indicates an expected call of GetAllResourcesFromSelector.
func (mr *MockClientInterfaceMockRecorder) GetAllResourcesFromSelector(selector, ns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllResourcesFromSelector", reflect.TypeOf((*MockClientInterface)(nil).GetAllResourcesFromSelector), selector, ns)
}

// GetAndUpdateStorageOwnerReference mocks base method.
func (m *MockClientInterface) GetAndUpdateStorageOwnerReference(pvc *v11.PersistentVolumeClaim, ownerReference ...v12.OwnerReference) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{pvc}
	for _, a := range ownerReference {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAndUpdateStorageOwnerReference", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetAndUpdateStorageOwnerReference indicates an expected call of GetAndUpdateStorageOwnerReference.
func (mr *MockClientInterfaceMockRecorder) GetAndUpdateStorageOwnerReference(pvc interface{}, ownerReference ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{pvc}, ownerReference...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAndUpdateStorageOwnerReference", reflect.TypeOf((*MockClientInterface)(nil).GetAndUpdateStorageOwnerReference), varargs...)
}

// GetBindableKindStatusRestMapping mocks base method.
func (m *MockClientInterface) GetBindableKindStatusRestMapping(bindableKindStatuses []v1alpha10.BindableKindsStatus) ([]*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBindableKindStatusRestMapping", bindableKindStatuses)
	ret0, _ := ret[0].([]*meta.RESTMapping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBindableKindStatusRestMapping indicates an expected call of GetBindableKindStatusRestMapping.
func (mr *MockClientInterfaceMockRecorder) GetBindableKindStatusRestMapping(bindableKindStatuses interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBindableKindStatusRestMapping", reflect.TypeOf((*MockClientInterface)(nil).GetBindableKindStatusRestMapping), bindableKindStatuses)
}

// GetBindableKinds mocks base method.
func (m *MockClientInterface) GetBindableKinds() (v1alpha10.BindableKinds, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBindableKinds")
	ret0, _ := ret[0].(v1alpha10.BindableKinds)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBindableKinds indicates an expected call of GetBindableKinds.
func (mr *MockClientInterfaceMockRecorder) GetBindableKinds() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBindableKinds", reflect.TypeOf((*MockClientInterface)(nil).GetBindableKinds))
}

// GetBindingServiceBinding mocks base method.
func (m *MockClientInterface) GetBindingServiceBinding(name string) (v1alpha10.ServiceBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBindingServiceBinding", name)
	ret0, _ := ret[0].(v1alpha10.ServiceBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBindingServiceBinding indicates an expected call of GetBindingServiceBinding.
func (mr *MockClientInterfaceMockRecorder) GetBindingServiceBinding(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBindingServiceBinding", reflect.TypeOf((*MockClientInterface)(nil).GetBindingServiceBinding), name)
}

// GetCSVWithCR mocks base method.
func (m *MockClientInterface) GetCSVWithCR(name string) (*v1alpha1.ClusterServiceVersion, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCSVWithCR", name)
	ret0, _ := ret[0].(*v1alpha1.ClusterServiceVersion)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCSVWithCR indicates an expected call of GetCSVWithCR.
func (mr *MockClientInterfaceMockRecorder) GetCSVWithCR(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCSVWithCR", reflect.TypeOf((*MockClientInterface)(nil).GetCSVWithCR), name)
}

// GetClient mocks base method.
func (m *MockClientInterface) GetClient() kubernetes.Interface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClient")
	ret0, _ := ret[0].(kubernetes.Interface)
	return ret0
}

// GetClient indicates an expected call of GetClient.
func (mr *MockClientInterfaceMockRecorder) GetClient() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClient", reflect.TypeOf((*MockClientInterface)(nil).GetClient))
}

// GetClientConfig mocks base method.
func (m *MockClientInterface) GetClientConfig() *rest.Config {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClientConfig")
	ret0, _ := ret[0].(*rest.Config)
	return ret0
}

// GetClientConfig indicates an expected call of GetClientConfig.
func (mr *MockClientInterfaceMockRecorder) GetClientConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClientConfig", reflect.TypeOf((*MockClientInterface)(nil).GetClientConfig))
}

// GetConfig mocks base method.
func (m *MockClientInterface) GetConfig() clientcmd.ClientConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetConfig")
	ret0, _ := ret[0].(clientcmd.ClientConfig)
	return ret0
}

// GetConfig indicates an expected call of GetConfig.
func (mr *MockClientInterfaceMockRecorder) GetConfig() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConfig", reflect.TypeOf((*MockClientInterface)(nil).GetConfig))
}

// GetCurrentNamespace mocks base method.
func (m *MockClientInterface) GetCurrentNamespace() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentNamespace")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetCurrentNamespace indicates an expected call of GetCurrentNamespace.
func (mr *MockClientInterfaceMockRecorder) GetCurrentNamespace() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentNamespace", reflect.TypeOf((*MockClientInterface)(nil).GetCurrentNamespace))
}

// GetCurrentProjectName mocks base method.
func (m *MockClientInterface) GetCurrentProjectName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentProjectName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetCurrentProjectName indicates an expected call of GetCurrentProjectName.
func (mr *MockClientInterfaceMockRecorder) GetCurrentProjectName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentProjectName", reflect.TypeOf((*MockClientInterface)(nil).GetCurrentProjectName))
}

// GetCustomResourcesFromCSV mocks base method.
func (m *MockClientInterface) GetCustomResourcesFromCSV(csv *v1alpha1.ClusterServiceVersion) *[]v1alpha1.CRDDescription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCustomResourcesFromCSV", csv)
	ret0, _ := ret[0].(*[]v1alpha1.CRDDescription)
	return ret0
}

// GetCustomResourcesFromCSV indicates an expected call of GetCustomResourcesFromCSV.
func (mr *MockClientInterfaceMockRecorder) GetCustomResourcesFromCSV(csv interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomResourcesFromCSV", reflect.TypeOf((*MockClientInterface)(nil).GetCustomResourcesFromCSV), csv)
}

// GetDeploymentAPIVersion mocks base method.
func (m *MockClientInterface) GetDeploymentAPIVersion() (schema.GroupVersionResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentAPIVersion")
	ret0, _ := ret[0].(schema.GroupVersionResource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentAPIVersion indicates an expected call of GetDeploymentAPIVersion.
func (mr *MockClientInterfaceMockRecorder) GetDeploymentAPIVersion() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentAPIVersion", reflect.TypeOf((*MockClientInterface)(nil).GetDeploymentAPIVersion))
}

// GetDeploymentByName mocks base method.
func (m *MockClientInterface) GetDeploymentByName(name string) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentByName", name)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentByName indicates an expected call of GetDeploymentByName.
func (mr *MockClientInterfaceMockRecorder) GetDeploymentByName(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentByName", reflect.TypeOf((*MockClientInterface)(nil).GetDeploymentByName), name)
}

// GetDeploymentFromSelector mocks base method.
func (m *MockClientInterface) GetDeploymentFromSelector(selector string) ([]v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentFromSelector", selector)
	ret0, _ := ret[0].([]v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentFromSelector indicates an expected call of GetDeploymentFromSelector.
func (mr *MockClientInterfaceMockRecorder) GetDeploymentFromSelector(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentFromSelector", reflect.TypeOf((*MockClientInterface)(nil).GetDeploymentFromSelector), selector)
}

// GetDynamicClient mocks base method.
func (m *MockClientInterface) GetDynamicClient() dynamic.Interface {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicClient")
	ret0, _ := ret[0].(dynamic.Interface)
	return ret0
}

// GetDynamicClient indicates an expected call of GetDynamicClient.
func (mr *MockClientInterfaceMockRecorder) GetDynamicClient() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicClient", reflect.TypeOf((*MockClientInterface)(nil).GetDynamicClient))
}

// GetDynamicResource mocks base method.
func (m *MockClientInterface) GetDynamicResource(gvr schema.GroupVersionResource, name string) (*unstructured.Unstructured, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicResource", gvr, name)
	ret0, _ := ret[0].(*unstructured.Unstructured)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDynamicResource indicates an expected call of GetDynamicResource.
func (mr *MockClientInterfaceMockRecorder) GetDynamicResource(gvr, name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDynamicResource", reflect.TypeOf((*MockClientInterface)(nil).GetDynamicResource), gvr, name)
}

// GetNamespace mocks base method.
func (m *MockClientInterface) GetNamespace(name string) (*v11.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", name)
	ret0, _ := ret[0].(*v11.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespace indicates an expected call of GetNamespace.
func (mr *MockClientInterfaceMockRecorder) GetNamespace(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespace", reflect.TypeOf((*MockClientInterface)(nil).GetNamespace), name)
}

// GetNamespaceNormal mocks base method.
func (m *MockClientInterface) GetNamespaceNormal(name string) (*v11.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaceNormal", name)
	ret0, _ := ret[0].(*v11.Namespace)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespaceNormal indicates an expected call of GetNamespaceNormal.
func (mr *MockClientInterfaceMockRecorder) GetNamespaceNormal(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaceNormal", reflect.TypeOf((*MockClientInterface)(nil).GetNamespaceNormal), name)
}

// GetNamespaces mocks base method.
func (m *MockClientInterface) GetNamespaces() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaces")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNamespaces indicates an expected call of GetNamespaces.
func (mr *MockClientInterfaceMockRecorder) GetNamespaces() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNamespaces", reflect.TypeOf((*MockClientInterface)(nil).GetNamespaces))
}

// GetOneDeployment mocks base method.
func (m *MockClientInterface) GetOneDeployment(componentName, appName string) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneDeployment", componentName, appName)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOneDeployment indicates an expected call of GetOneDeployment.
func (mr *MockClientInterfaceMockRecorder) GetOneDeployment(componentName, appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneDeployment", reflect.TypeOf((*MockClientInterface)(nil).GetOneDeployment), componentName, appName)
}

// GetOneDeploymentFromSelector mocks base method.
func (m *MockClientInterface) GetOneDeploymentFromSelector(selector string) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneDeploymentFromSelector", selector)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOneDeploymentFromSelector indicates an expected call of GetOneDeploymentFromSelector.
func (mr *MockClientInterfaceMockRecorder) GetOneDeploymentFromSelector(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneDeploymentFromSelector", reflect.TypeOf((*MockClientInterface)(nil).GetOneDeploymentFromSelector), selector)
}

// GetOnePodFromSelector mocks base method.
func (m *MockClientInterface) GetOnePodFromSelector(selector string) (*v11.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOnePodFromSelector", selector)
	ret0, _ := ret[0].(*v11.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOnePodFromSelector indicates an expected call of GetOnePodFromSelector.
func (mr *MockClientInterfaceMockRecorder) GetOnePodFromSelector(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOnePodFromSelector", reflect.TypeOf((*MockClientInterface)(nil).GetOnePodFromSelector), selector)
}

// GetOneService mocks base method.
func (m *MockClientInterface) GetOneService(componentName, appName string) (*v11.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneService", componentName, appName)
	ret0, _ := ret[0].(*v11.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOneService indicates an expected call of GetOneService.
func (mr *MockClientInterfaceMockRecorder) GetOneService(componentName, appName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneService", reflect.TypeOf((*MockClientInterface)(nil).GetOneService), componentName, appName)
}

// GetOneServiceFromSelector mocks base method.
func (m *MockClientInterface) GetOneServiceFromSelector(selector string) (*v11.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneServiceFromSelector", selector)
	ret0, _ := ret[0].(*v11.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOneServiceFromSelector indicates an expected call of GetOneServiceFromSelector.
func (mr *MockClientInterfaceMockRecorder) GetOneServiceFromSelector(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOneServiceFromSelector", reflect.TypeOf((*MockClientInterface)(nil).GetOneServiceFromSelector), selector)
}

// GetOperatorGVRList mocks base method.
func (m *MockClientInterface) GetOperatorGVRList() ([]meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOperatorGVRList")
	ret0, _ := ret[0].([]meta.RESTMapping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOperatorGVRList indicates an expected call of GetOperatorGVRList.
func (mr *MockClientInterfaceMockRecorder) GetOperatorGVRList() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOperatorGVRList", reflect.TypeOf((*MockClientInterface)(nil).GetOperatorGVRList))
}

// GetPVCFromName mocks base method.
func (m *MockClientInterface) GetPVCFromName(pvcName string) (*v11.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPVCFromName", pvcName)
	ret0, _ := ret[0].(*v11.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPVCFromName indicates an expected call of GetPVCFromName.
func (mr *MockClientInterfaceMockRecorder) GetPVCFromName(pvcName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPVCFromName", reflect.TypeOf((*MockClientInterface)(nil).GetPVCFromName), pvcName)
}

// GetPodLogs mocks base method.
func (m *MockClientInterface) GetPodLogs(podName, containerName string, followLog bool) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodLogs", podName, containerName, followLog)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodLogs indicates an expected call of GetPodLogs.
func (mr *MockClientInterfaceMockRecorder) GetPodLogs(podName, containerName, followLog interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodLogs", reflect.TypeOf((*MockClientInterface)(nil).GetPodLogs), podName, containerName, followLog)
}

// GetPodUsingComponentName mocks base method.
func (m *MockClientInterface) GetPodUsingComponentName(componentName string) (*v11.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodUsingComponentName", componentName)
	ret0, _ := ret[0].(*v11.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPodUsingComponentName indicates an expected call of GetPodUsingComponentName.
func (mr *MockClientInterfaceMockRecorder) GetPodUsingComponentName(componentName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPodUsingComponentName", reflect.TypeOf((*MockClientInterface)(nil).GetPodUsingComponentName), componentName)
}

// GetProject mocks base method.
func (m *MockClientInterface) GetProject(projectName string) (*v1.Project, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProject", projectName)
	ret0, _ := ret[0].(*v1.Project)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProject indicates an expected call of GetProject.
func (mr *MockClientInterfaceMockRecorder) GetProject(projectName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProject", reflect.TypeOf((*MockClientInterface)(nil).GetProject), projectName)
}

// GetReplicaSetByName mocks base method.
func (m *MockClientInterface) GetReplicaSetByName(name string) (*v10.ReplicaSet, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicaSetByName", name)
	ret0, _ := ret[0].(*v10.ReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReplicaSetByName indicates an expected call of GetReplicaSetByName.
func (mr *MockClientInterfaceMockRecorder) GetReplicaSetByName(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicaSetByName", reflect.TypeOf((*MockClientInterface)(nil).GetReplicaSetByName), name)
}

// GetResourceSpecDefinition mocks base method.
func (m *MockClientInterface) GetResourceSpecDefinition(group, version, kind string) (*spec.Schema, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourceSpecDefinition", group, version, kind)
	ret0, _ := ret[0].(*spec.Schema)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourceSpecDefinition indicates an expected call of GetResourceSpecDefinition.
func (mr *MockClientInterfaceMockRecorder) GetResourceSpecDefinition(group, version, kind interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceSpecDefinition", reflect.TypeOf((*MockClientInterface)(nil).GetResourceSpecDefinition), group, version, kind)
}

// GetRestMappingFromGVK mocks base method.
func (m *MockClientInterface) GetRestMappingFromGVK(gvk schema.GroupVersionKind) (*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRestMappingFromGVK", gvk)
	ret0, _ := ret[0].(*meta.RESTMapping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRestMappingFromGVK indicates an expected call of GetRestMappingFromGVK.
func (mr *MockClientInterfaceMockRecorder) GetRestMappingFromGVK(gvk interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRestMappingFromGVK", reflect.TypeOf((*MockClientInterface)(nil).GetRestMappingFromGVK), gvk)
}

// GetRestMappingFromUnstructured mocks base method.
func (m *MockClientInterface) GetRestMappingFromUnstructured(arg0 unstructured.Unstructured) (*meta.RESTMapping, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRestMappingFromUnstructured", arg0)
	ret0, _ := ret[0].(*meta.RESTMapping)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRestMappingFromUnstructured indicates an expected call of GetRestMappingFromUnstructured.
func (mr *MockClientInterfaceMockRecorder) GetRestMappingFromUnstructured(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRestMappingFromUnstructured", reflect.TypeOf((*MockClientInterface)(nil).GetRestMappingFromUnstructured), arg0)
}

// GetSecret mocks base method.
func (m *MockClientInterface) GetSecret(name, namespace string) (*v11.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecret", name, namespace)
	ret0, _ := ret[0].(*v11.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSecret indicates an expected call of GetSecret.
func (mr *MockClientInterfaceMockRecorder) GetSecret(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSecret", reflect.TypeOf((*MockClientInterface)(nil).GetSecret), name, namespace)
}

// GetServerVersion mocks base method.
func (m *MockClientInterface) GetServerVersion(timeout time.Duration) (*ServerInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetServerVersion", timeout)
	ret0, _ := ret[0].(*ServerInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServerVersion indicates an expected call of GetServerVersion.
func (mr *MockClientInterfaceMockRecorder) GetServerVersion(timeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerVersion", reflect.TypeOf((*MockClientInterface)(nil).GetServerVersion), timeout)
}

// GetSpecServiceBinding mocks base method.
func (m *MockClientInterface) GetSpecServiceBinding(name string) (v1alpha3.ServiceBinding, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSpecServiceBinding", name)
	ret0, _ := ret[0].(v1alpha3.ServiceBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSpecServiceBinding indicates an expected call of GetSpecServiceBinding.
func (mr *MockClientInterfaceMockRecorder) GetSpecServiceBinding(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSpecServiceBinding", reflect.TypeOf((*MockClientInterface)(nil).GetSpecServiceBinding), name)
}

// IsCSVSupported mocks base method.
func (m *MockClientInterface) IsCSVSupported() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsCSVSupported")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsCSVSupported indicates an expected call of IsCSVSupported.
func (mr *MockClientInterfaceMockRecorder) IsCSVSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCSVSupported", reflect.TypeOf((*MockClientInterface)(nil).IsCSVSupported))
}

// IsDeploymentExtensionsV1Beta1 mocks base method.
func (m *MockClientInterface) IsDeploymentExtensionsV1Beta1() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDeploymentExtensionsV1Beta1")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsDeploymentExtensionsV1Beta1 indicates an expected call of IsDeploymentExtensionsV1Beta1.
func (mr *MockClientInterfaceMockRecorder) IsDeploymentExtensionsV1Beta1() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDeploymentExtensionsV1Beta1", reflect.TypeOf((*MockClientInterface)(nil).IsDeploymentExtensionsV1Beta1))
}

// IsProjectSupported mocks base method.
func (m *MockClientInterface) IsProjectSupported() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsProjectSupported")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsProjectSupported indicates an expected call of IsProjectSupported.
func (mr *MockClientInterfaceMockRecorder) IsProjectSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsProjectSupported", reflect.TypeOf((*MockClientInterface)(nil).IsProjectSupported))
}

// IsResourceSupported mocks base method.
func (m *MockClientInterface) IsResourceSupported(apiGroup, apiVersion, resourceName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsResourceSupported", apiGroup, apiVersion, resourceName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsResourceSupported indicates an expected call of IsResourceSupported.
func (mr *MockClientInterfaceMockRecorder) IsResourceSupported(apiGroup, apiVersion, resourceName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsResourceSupported", reflect.TypeOf((*MockClientInterface)(nil).IsResourceSupported), apiGroup, apiVersion, resourceName)
}

// IsSSASupported mocks base method.
func (m *MockClientInterface) IsSSASupported() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSSASupported")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsSSASupported indicates an expected call of IsSSASupported.
func (mr *MockClientInterfaceMockRecorder) IsSSASupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSSASupported", reflect.TypeOf((*MockClientInterface)(nil).IsSSASupported))
}

// IsServiceBindingSupported mocks base method.
func (m *MockClientInterface) IsServiceBindingSupported() (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsServiceBindingSupported")
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsServiceBindingSupported indicates an expected call of IsServiceBindingSupported.
func (mr *MockClientInterfaceMockRecorder) IsServiceBindingSupported() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsServiceBindingSupported", reflect.TypeOf((*MockClientInterface)(nil).IsServiceBindingSupported))
}

// ListClusterServiceVersions mocks base method.
func (m *MockClientInterface) ListClusterServiceVersions() (*v1alpha1.ClusterServiceVersionList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusterServiceVersions")
	ret0, _ := ret[0].(*v1alpha1.ClusterServiceVersionList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClusterServiceVersions indicates an expected call of ListClusterServiceVersions.
func (mr *MockClientInterfaceMockRecorder) ListClusterServiceVersions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusterServiceVersions", reflect.TypeOf((*MockClientInterface)(nil).ListClusterServiceVersions))
}

// ListDynamicResources mocks base method.
func (m *MockClientInterface) ListDynamicResources(gvr schema.GroupVersionResource) (*unstructured.UnstructuredList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDynamicResources", gvr)
	ret0, _ := ret[0].(*unstructured.UnstructuredList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDynamicResources indicates an expected call of ListDynamicResources.
func (mr *MockClientInterfaceMockRecorder) ListDynamicResources(gvr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDynamicResources", reflect.TypeOf((*MockClientInterface)(nil).ListDynamicResources), gvr)
}

// ListPVCNames mocks base method.
func (m *MockClientInterface) ListPVCNames(selector string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPVCNames", selector)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPVCNames indicates an expected call of ListPVCNames.
func (mr *MockClientInterfaceMockRecorder) ListPVCNames(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPVCNames", reflect.TypeOf((*MockClientInterface)(nil).ListPVCNames), selector)
}

// ListPVCs mocks base method.
func (m *MockClientInterface) ListPVCs(selector string) ([]v11.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPVCs", selector)
	ret0, _ := ret[0].([]v11.PersistentVolumeClaim)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPVCs indicates an expected call of ListPVCs.
func (mr *MockClientInterfaceMockRecorder) ListPVCs(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPVCs", reflect.TypeOf((*MockClientInterface)(nil).ListPVCs), selector)
}

// ListProjectNames mocks base method.
func (m *MockClientInterface) ListProjectNames() ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProjectNames")
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProjectNames indicates an expected call of ListProjectNames.
func (mr *MockClientInterfaceMockRecorder) ListProjectNames() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectNames", reflect.TypeOf((*MockClientInterface)(nil).ListProjectNames))
}

// ListSecrets mocks base method.
func (m *MockClientInterface) ListSecrets(labelSelector string) ([]v11.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSecrets", labelSelector)
	ret0, _ := ret[0].([]v11.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSecrets indicates an expected call of ListSecrets.
func (mr *MockClientInterfaceMockRecorder) ListSecrets(labelSelector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSecrets", reflect.TypeOf((*MockClientInterface)(nil).ListSecrets), labelSelector)
}

// ListServices mocks base method.
func (m *MockClientInterface) ListServices(selector string) ([]v11.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServices", selector)
	ret0, _ := ret[0].([]v11.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListServices indicates an expected call of ListServices.
func (mr *MockClientInterfaceMockRecorder) ListServices(selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListServices", reflect.TypeOf((*MockClientInterface)(nil).ListServices), selector)
}

// NewServiceBindingServiceObject mocks base method.
func (m *MockClientInterface) NewServiceBindingServiceObject(unstructuredService unstructured.Unstructured, bindingName string) (v1alpha10.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewServiceBindingServiceObject", unstructuredService, bindingName)
	ret0, _ := ret[0].(v1alpha10.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewServiceBindingServiceObject indicates an expected call of NewServiceBindingServiceObject.
func (mr *MockClientInterfaceMockRecorder) NewServiceBindingServiceObject(unstructuredService, bindingName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewServiceBindingServiceObject", reflect.TypeOf((*MockClientInterface)(nil).NewServiceBindingServiceObject), unstructuredService, bindingName)
}

// RunLogout mocks base method.
func (m *MockClientInterface) RunLogout(stdout io.Writer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunLogout", stdout)
	ret0, _ := ret[0].(error)
	return ret0
}

// RunLogout indicates an expected call of RunLogout.
func (mr *MockClientInterfaceMockRecorder) RunLogout(stdout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunLogout", reflect.TypeOf((*MockClientInterface)(nil).RunLogout), stdout)
}

// SetCurrentNamespace mocks base method.
func (m *MockClientInterface) SetCurrentNamespace(namespace string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCurrentNamespace", namespace)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetCurrentNamespace indicates an expected call of SetCurrentNamespace.
func (mr *MockClientInterfaceMockRecorder) SetCurrentNamespace(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentNamespace", reflect.TypeOf((*MockClientInterface)(nil).SetCurrentNamespace), namespace)
}

// SetDiscoveryInterface mocks base method.
func (m *MockClientInterface) SetDiscoveryInterface(client discovery.DiscoveryInterface) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDiscoveryInterface", client)
}

// SetDiscoveryInterface indicates an expected call of SetDiscoveryInterface.
func (mr *MockClientInterfaceMockRecorder) SetDiscoveryInterface(client interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDiscoveryInterface", reflect.TypeOf((*MockClientInterface)(nil).SetDiscoveryInterface), client)
}

// SetNamespace mocks base method.
func (m *MockClientInterface) SetNamespace(ns string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNamespace", ns)
}

// SetNamespace indicates an expected call of SetNamespace.
func (mr *MockClientInterfaceMockRecorder) SetNamespace(ns interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNamespace", reflect.TypeOf((*MockClientInterface)(nil).SetNamespace), ns)
}

// SetupPortForwarding mocks base method.
func (m *MockClientInterface) SetupPortForwarding(pod *v11.Pod, portPairs []string, out, errOut io.Writer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetupPortForwarding", pod, portPairs, out, errOut)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetupPortForwarding indicates an expected call of SetupPortForwarding.
func (mr *MockClientInterfaceMockRecorder) SetupPortForwarding(pod, portPairs, out, errOut interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetupPortForwarding", reflect.TypeOf((*MockClientInterface)(nil).SetupPortForwarding), pod, portPairs, out, errOut)
}

// TryWithBlockOwnerDeletion mocks base method.
func (m *MockClientInterface) TryWithBlockOwnerDeletion(ownerReference v12.OwnerReference, exec func(v12.OwnerReference) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryWithBlockOwnerDeletion", ownerReference, exec)
	ret0, _ := ret[0].(error)
	return ret0
}

// TryWithBlockOwnerDeletion indicates an expected call of TryWithBlockOwnerDeletion.
func (mr *MockClientInterfaceMockRecorder) TryWithBlockOwnerDeletion(ownerReference, exec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TryWithBlockOwnerDeletion", reflect.TypeOf((*MockClientInterface)(nil).TryWithBlockOwnerDeletion), ownerReference, exec)
}

// UpdateDeployment mocks base method.
func (m *MockClientInterface) UpdateDeployment(deploy v10.Deployment) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDeployment", deploy)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDeployment indicates an expected call of UpdateDeployment.
func (mr *MockClientInterfaceMockRecorder) UpdateDeployment(deploy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeployment", reflect.TypeOf((*MockClientInterface)(nil).UpdateDeployment), deploy)
}

// UpdateDynamicResource mocks base method.
func (m *MockClientInterface) UpdateDynamicResource(gvr schema.GroupVersionResource, name string, u *unstructured.Unstructured) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDynamicResource", gvr, name, u)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateDynamicResource indicates an expected call of UpdateDynamicResource.
func (mr *MockClientInterfaceMockRecorder) UpdateDynamicResource(gvr, name, u interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDynamicResource", reflect.TypeOf((*MockClientInterface)(nil).UpdateDynamicResource), gvr, name, u)
}

// UpdatePVCLabels mocks base method.
func (m *MockClientInterface) UpdatePVCLabels(pvc *v11.PersistentVolumeClaim, labels map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePVCLabels", pvc, labels)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdatePVCLabels indicates an expected call of UpdatePVCLabels.
func (mr *MockClientInterfaceMockRecorder) UpdatePVCLabels(pvc, labels interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePVCLabels", reflect.TypeOf((*MockClientInterface)(nil).UpdatePVCLabels), pvc, labels)
}

// UpdateSecret mocks base method.
func (m *MockClientInterface) UpdateSecret(secret *v11.Secret, namespace string) (*v11.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecret", secret, namespace)
	ret0, _ := ret[0].(*v11.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecret indicates an expected call of UpdateSecret.
func (mr *MockClientInterfaceMockRecorder) UpdateSecret(secret, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecret", reflect.TypeOf((*MockClientInterface)(nil).UpdateSecret), secret, namespace)
}

// UpdateService mocks base method.
func (m *MockClientInterface) UpdateService(svc v11.Service) (*v11.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateService", svc)
	ret0, _ := ret[0].(*v11.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateService indicates an expected call of UpdateService.
func (mr *MockClientInterfaceMockRecorder) UpdateService(svc interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockClientInterface)(nil).UpdateService), svc)
}

// UpdateStorageOwnerReference mocks base method.
func (m *MockClientInterface) UpdateStorageOwnerReference(pvc *v11.PersistentVolumeClaim, ownerReference ...v12.OwnerReference) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{pvc}
	for _, a := range ownerReference {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateStorageOwnerReference", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateStorageOwnerReference indicates an expected call of UpdateStorageOwnerReference.
func (mr *MockClientInterfaceMockRecorder) UpdateStorageOwnerReference(pvc interface{}, ownerReference ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{pvc}, ownerReference...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStorageOwnerReference", reflect.TypeOf((*MockClientInterface)(nil).UpdateStorageOwnerReference), varargs...)
}

// WaitAndGetPodWithEvents mocks base method.
func (m *MockClientInterface) WaitAndGetPodWithEvents(selector string, desiredPhase v11.PodPhase, pushTimeout time.Duration) (*v11.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitAndGetPodWithEvents", selector, desiredPhase, pushTimeout)
	ret0, _ := ret[0].(*v11.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitAndGetPodWithEvents indicates an expected call of WaitAndGetPodWithEvents.
func (mr *MockClientInterfaceMockRecorder) WaitAndGetPodWithEvents(selector, desiredPhase, pushTimeout interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitAndGetPodWithEvents", reflect.TypeOf((*MockClientInterface)(nil).WaitAndGetPodWithEvents), selector, desiredPhase, pushTimeout)
}

// WaitAndGetSecret mocks base method.
func (m *MockClientInterface) WaitAndGetSecret(name, namespace string) (*v11.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitAndGetSecret", name, namespace)
	ret0, _ := ret[0].(*v11.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitAndGetSecret indicates an expected call of WaitAndGetSecret.
func (mr *MockClientInterfaceMockRecorder) WaitAndGetSecret(name, namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitAndGetSecret", reflect.TypeOf((*MockClientInterface)(nil).WaitAndGetSecret), name, namespace)
}

// WaitForDeploymentRollout mocks base method.
func (m *MockClientInterface) WaitForDeploymentRollout(deploymentName string) (*v10.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForDeploymentRollout", deploymentName)
	ret0, _ := ret[0].(*v10.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WaitForDeploymentRollout indicates an expected call of WaitForDeploymentRollout.
func (mr *MockClientInterfaceMockRecorder) WaitForDeploymentRollout(deploymentName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForDeploymentRollout", reflect.TypeOf((*MockClientInterface)(nil).WaitForDeploymentRollout), deploymentName)
}

// WaitForPodDeletion mocks base method.
func (m *MockClientInterface) WaitForPodDeletion(name string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForPodDeletion", name)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitForPodDeletion indicates an expected call of WaitForPodDeletion.
func (mr *MockClientInterfaceMockRecorder) WaitForPodDeletion(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForPodDeletion", reflect.TypeOf((*MockClientInterface)(nil).WaitForPodDeletion), name)
}

// WaitForServiceAccountInNamespace mocks base method.
func (m *MockClientInterface) WaitForServiceAccountInNamespace(namespace, serviceAccountName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForServiceAccountInNamespace", namespace, serviceAccountName)
	ret0, _ := ret[0].(error)
	return ret0
}

// WaitForServiceAccountInNamespace indicates an expected call of WaitForServiceAccountInNamespace.
func (mr *MockClientInterfaceMockRecorder) WaitForServiceAccountInNamespace(namespace, serviceAccountName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForServiceAccountInNamespace", reflect.TypeOf((*MockClientInterface)(nil).WaitForServiceAccountInNamespace), namespace, serviceAccountName)
}