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"
	v10 "github.com/openshift/api/route/v1"
	v1alpha1 "github.com/operator-framework/api/pkg/operators/v1alpha1"
	unions "github.com/redhat-developer/odo/pkg/kclient/unions"
	log "github.com/redhat-developer/odo/pkg/log"
	v11 "k8s.io/api/apps/v1"
	v12 "k8s.io/api/core/v1"
	meta "k8s.io/apimachinery/pkg/api/meta"
	v13 "k8s.io/apimachinery/pkg/apis/meta/v1"
	unstructured "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	intstr "k8s.io/apimachinery/pkg/util/intstr"
	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 v11.Deployment) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyDeployment", deploy)
	ret0, _ := ret[0].(*v11.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]v12.Event, spinner *log.Status, quit <-chan int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "CollectEvents", selector, events, spinner, quit)
}

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

// CreateDeployment mocks base method.
func (m *MockClientInterface) CreateDeployment(deploy v11.Deployment) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDeployment", deploy)
	ret0, _ := ret[0].(*v11.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, gvr *meta.RESTMapping) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDynamicResource", exampleCustomResource, gvr)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// CreateNamespace mocks base method.
func (m *MockClientInterface) CreateNamespace(name string) (*v12.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNamespace", name)
	ret0, _ := ret[0].(*v12.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 v12.PersistentVolumeClaim) (*v12.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePVC", pvc)
	ret0, _ := ret[0].(*v12.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)
}

// CreateRoute mocks base method.
func (m *MockClientInterface) CreateRoute(name, serviceName string, portNumber intstr.IntOrString, labels map[string]string, secureURL bool, path string, ownerReference v13.OwnerReference) (*v10.Route, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRoute", name, serviceName, portNumber, labels, secureURL, path, ownerReference)
	ret0, _ := ret[0].(*v10.Route)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRoute indicates an expected call of CreateRoute.
func (mr *MockClientInterfaceMockRecorder) CreateRoute(name, serviceName, portNumber, labels, secureURL, path, ownerReference interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockClientInterface)(nil).CreateRoute), name, serviceName, portNumber, labels, secureURL, path, ownerReference)
}

// CreateSecret mocks base method.
func (m *MockClientInterface) CreateSecret(objectMeta v13.ObjectMeta, data map[string]string, ownerReference v13.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 v13.ObjectMeta, svc *v12.Service, ownerReference v13.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 v12.Service) (*v12.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateService", svc)
	ret0, _ := ret[0].(*v12.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 v13.ObjectMeta) (*v12.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateTLSSecret", tlsCertificate, tlsPrivKey, objectMeta)
	ret0, _ := ret[0].(*v12.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)
}

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

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

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

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

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

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

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

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

// 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)
}

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

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

// 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)
}

// GetAndUpdateStorageOwnerReference mocks base method.
func (m *MockClientInterface) GetAndUpdateStorageOwnerReference(pvc *v12.PersistentVolumeClaim, ownerReference ...v13.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...)
}

// 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() (v13.GroupVersionResource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentAPIVersion")
	ret0, _ := ret[0].(v13.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) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentByName", name)
	ret0, _ := ret[0].(*v11.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) ([]v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDeploymentFromSelector", selector)
	ret0, _ := ret[0].([]v11.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)
}

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

// GetDeploymentLabelValues indicates an expected call of GetDeploymentLabelValues.
func (mr *MockClientInterfaceMockRecorder) GetDeploymentLabelValues(label, selector interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeploymentLabelValues", reflect.TypeOf((*MockClientInterface)(nil).GetDeploymentLabelValues), label, 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(group, version, resource, name string) (*unstructured.Unstructured, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDynamicResource", group, version, resource, name)
	ret0, _ := ret[0].(*unstructured.Unstructured)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetNamespace mocks base method.
func (m *MockClientInterface) GetNamespace(name string) (*v12.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespace", name)
	ret0, _ := ret[0].(*v12.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) (*v12.Namespace, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNamespaceNormal", name)
	ret0, _ := ret[0].(*v12.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) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneDeployment", componentName, appName)
	ret0, _ := ret[0].(*v11.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) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneDeploymentFromSelector", selector)
	ret0, _ := ret[0].(*v11.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)
}

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

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

// GetOnePodFromSelector mocks base method.
func (m *MockClientInterface) GetOnePodFromSelector(selector string) (*v12.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOnePodFromSelector", selector)
	ret0, _ := ret[0].(*v12.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)
}

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

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

// GetOneService mocks base method.
func (m *MockClientInterface) GetOneService(componentName, appName string) (*v12.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneService", componentName, appName)
	ret0, _ := ret[0].(*v12.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) (*v12.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOneServiceFromSelector", selector)
	ret0, _ := ret[0].(*v12.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) (*v12.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPVCFromName", pvcName)
	ret0, _ := ret[0].(*v12.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) (*v12.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPodUsingComponentName", componentName)
	ret0, _ := ret[0].(*v12.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)
}

// 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)
}

// 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)
}

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

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

// GetSecret mocks base method.
func (m *MockClientInterface) GetSecret(name, namespace string) (*v12.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSecret", name, namespace)
	ret0, _ := ret[0].(*v12.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)
}

// 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)
}

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

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

// 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))
}

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

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

// 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))
}

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

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

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

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

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

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

// 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) ([]v12.PersistentVolumeClaim, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPVCs", selector)
	ret0, _ := ret[0].([]v12.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))
}

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

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

// ListSecrets mocks base method.
func (m *MockClientInterface) ListSecrets(labelSelector string) ([]v12.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSecrets", labelSelector)
	ret0, _ := ret[0].([]v12.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) ([]v12.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListServices", selector)
	ret0, _ := ret[0].([]v12.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)
}

// 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)
}

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

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

// UpdateDeployment mocks base method.
func (m *MockClientInterface) UpdateDeployment(deploy v11.Deployment) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDeployment", deploy)
	ret0, _ := ret[0].(*v11.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(group, version, resource, name string, u *unstructured.Unstructured) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDynamicResource", group, version, resource, name, u)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdatePVCLabels mocks base method.
func (m *MockClientInterface) UpdatePVCLabels(pvc *v12.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 *v12.Secret, namespace string) (*v12.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateSecret", secret, namespace)
	ret0, _ := ret[0].(*v12.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 v12.Service) (*v12.Service, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateService", svc)
	ret0, _ := ret[0].(*v12.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 *v12.PersistentVolumeClaim, ownerReference ...v13.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 v12.PodPhase, waitMessage string, pushTimeout time.Duration) (*v12.Pod, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitAndGetPodWithEvents", selector, desiredPhase, waitMessage, pushTimeout)
	ret0, _ := ret[0].(*v12.Pod)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WaitAndGetSecret mocks base method.
func (m *MockClientInterface) WaitAndGetSecret(name, namespace string) (*v12.Secret, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitAndGetSecret", name, namespace)
	ret0, _ := ret[0].(*v12.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)
}

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

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

// WaitForDeploymentRollout mocks base method.
func (m *MockClientInterface) WaitForDeploymentRollout(deploymentName string) (*v11.Deployment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitForDeploymentRollout", deploymentName)
	ret0, _ := ret[0].(*v11.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)
}