// Code generated by MockGen. DO NOT EDIT.
// SourceClient: ./pkg/lib/operatorclient/client.go

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

import (
	gomock "github.com/golang/mock/gomock"
	v1 "k8s.io/api/apps/v1"
	v10 "k8s.io/api/core/v1"
	v11 "k8s.io/api/rbac/v1"
	clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
	v12 "k8s.io/apimachinery/pkg/apis/meta/v1"
	unstructured "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	labels "k8s.io/apimachinery/pkg/labels"
	kubernetes "k8s.io/client-go/kubernetes"
	v13 "k8s.io/kube-aggregator/pkg/apis/apiregistration/v1"
	clientset0 "k8s.io/kube-aggregator/pkg/client/clientset_generated/clientset"
	reflect "reflect"
)

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

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

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

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

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

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

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

// CreateAPIService mocks base method
func (m *MockClientInterface) CreateAPIService(arg0 *v13.APIService) (*v13.APIService, error) {
	ret := m.ctrl.Call(m, "CreateAPIService", arg0)
	ret0, _ := ret[0].(*v13.APIService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateAPIService mocks base method
func (m *MockClientInterface) UpdateAPIService(modified *v13.APIService) (*v13.APIService, error) {
	ret := m.ctrl.Call(m, "UpdateAPIService", modified)
	ret0, _ := ret[0].(*v13.APIService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetCustomResource mocks base method
func (m *MockClientInterface) GetCustomResource(apiGroup, version, namespace, resourceKind, resourceName string) (*unstructured.Unstructured, error) {
	ret := m.ctrl.Call(m, "GetCustomResource", apiGroup, version, namespace, resourceKind, resourceName)
	ret0, _ := ret[0].(*unstructured.Unstructured)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomResource indicates an expected call of GetCustomResource
func (mr *MockClientInterfaceMockRecorder) GetCustomResource(apiGroup, version, namespace, resourceKind, resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomResource", reflect.TypeOf((*MockClientInterface)(nil).GetCustomResource), apiGroup, version, namespace, resourceKind, resourceName)
}

// GetCustomResourceRaw mocks base method
func (m *MockClientInterface) GetCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName string) ([]byte, error) {
	ret := m.ctrl.Call(m, "GetCustomResourceRaw", apiGroup, version, namespace, resourceKind, resourceName)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomResourceRaw indicates an expected call of GetCustomResourceRaw
func (mr *MockClientInterfaceMockRecorder) GetCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomResourceRaw", reflect.TypeOf((*MockClientInterface)(nil).GetCustomResourceRaw), apiGroup, version, namespace, resourceKind, resourceName)
}

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

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

// CreateCustomResourceRaw mocks base method
func (m *MockClientInterface) CreateCustomResourceRaw(apiGroup, version, namespace, kind string, data []byte) error {
	ret := m.ctrl.Call(m, "CreateCustomResourceRaw", apiGroup, version, namespace, kind, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCustomResourceRaw indicates an expected call of CreateCustomResourceRaw
func (mr *MockClientInterfaceMockRecorder) CreateCustomResourceRaw(apiGroup, version, namespace, kind, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomResourceRaw", reflect.TypeOf((*MockClientInterface)(nil).CreateCustomResourceRaw), apiGroup, version, namespace, kind, data)
}

// CreateCustomResourceRawIfNotFound mocks base method
func (m *MockClientInterface) CreateCustomResourceRawIfNotFound(apiGroup, version, namespace, kind, name string, data []byte) (bool, error) {
	ret := m.ctrl.Call(m, "CreateCustomResourceRawIfNotFound", apiGroup, version, namespace, kind, name, data)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCustomResourceRawIfNotFound indicates an expected call of CreateCustomResourceRawIfNotFound
func (mr *MockClientInterfaceMockRecorder) CreateCustomResourceRawIfNotFound(apiGroup, version, namespace, kind, name, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomResourceRawIfNotFound", reflect.TypeOf((*MockClientInterface)(nil).CreateCustomResourceRawIfNotFound), apiGroup, version, namespace, kind, name, data)
}

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

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

// UpdateCustomResourceRaw mocks base method
func (m *MockClientInterface) UpdateCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName string, data []byte) error {
	ret := m.ctrl.Call(m, "UpdateCustomResourceRaw", apiGroup, version, namespace, resourceKind, resourceName, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCustomResourceRaw indicates an expected call of UpdateCustomResourceRaw
func (mr *MockClientInterfaceMockRecorder) UpdateCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomResourceRaw", reflect.TypeOf((*MockClientInterface)(nil).UpdateCustomResourceRaw), apiGroup, version, namespace, resourceKind, resourceName, data)
}

// CreateOrUpdateCustomeResourceRaw mocks base method
func (m *MockClientInterface) CreateOrUpdateCustomeResourceRaw(apiGroup, version, namespace, resourceKind, resourceName string, data []byte) error {
	ret := m.ctrl.Call(m, "CreateOrUpdateCustomeResourceRaw", apiGroup, version, namespace, resourceKind, resourceName, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateOrUpdateCustomeResourceRaw indicates an expected call of CreateOrUpdateCustomeResourceRaw
func (mr *MockClientInterfaceMockRecorder) CreateOrUpdateCustomeResourceRaw(apiGroup, version, namespace, resourceKind, resourceName, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateCustomeResourceRaw", reflect.TypeOf((*MockClientInterface)(nil).CreateOrUpdateCustomeResourceRaw), apiGroup, version, namespace, resourceKind, resourceName, data)
}

// DeleteCustomResource mocks base method
func (m *MockClientInterface) DeleteCustomResource(apiGroup, version, namespace, resourceKind, resourceName string) error {
	ret := m.ctrl.Call(m, "DeleteCustomResource", apiGroup, version, namespace, resourceKind, resourceName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCustomResource indicates an expected call of DeleteCustomResource
func (mr *MockClientInterfaceMockRecorder) DeleteCustomResource(apiGroup, version, namespace, resourceKind, resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomResource", reflect.TypeOf((*MockClientInterface)(nil).DeleteCustomResource), apiGroup, version, namespace, resourceKind, resourceName)
}

// AtomicModifyCustomResource mocks base method
func (m *MockClientInterface) AtomicModifyCustomResource(apiGroup, version, namespace, resourceKind, resourceName string, f CustomResourceModifier, data interface{}) error {
	ret := m.ctrl.Call(m, "AtomicModifyCustomResource", apiGroup, version, namespace, resourceKind, resourceName, f, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// AtomicModifyCustomResource indicates an expected call of AtomicModifyCustomResource
func (mr *MockClientInterfaceMockRecorder) AtomicModifyCustomResource(apiGroup, version, namespace, resourceKind, resourceName, f, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AtomicModifyCustomResource", reflect.TypeOf((*MockClientInterface)(nil).AtomicModifyCustomResource), apiGroup, version, namespace, resourceKind, resourceName, f, data)
}

// ListCustomResource mocks base method
func (m *MockClientInterface) ListCustomResource(apiGroup, version, namespace, resourceKind string) (*CustomResourceList, error) {
	ret := m.ctrl.Call(m, "ListCustomResource", apiGroup, version, namespace, resourceKind)
	ret0, _ := ret[0].(*CustomResourceList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateSecret mocks base method
func (m *MockClientInterface) CreateSecret(arg0 *v10.Secret) (*v10.Secret, error) {
	ret := m.ctrl.Call(m, "CreateSecret", arg0)
	ret0, _ := ret[0].(*v10.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateSecret mocks base method
func (m *MockClientInterface) UpdateSecret(modified *v10.Secret) (*v10.Secret, error) {
	ret := m.ctrl.Call(m, "UpdateSecret", modified)
	ret0, _ := ret[0].(*v10.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// DeleteService mocks base method
func (m *MockClientInterface) DeleteService(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteService", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateServiceAccount mocks base method
func (m *MockClientInterface) CreateServiceAccount(arg0 *v10.ServiceAccount) (*v10.ServiceAccount, error) {
	ret := m.ctrl.Call(m, "CreateServiceAccount", arg0)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UpdateServiceAccount mocks base method
func (m *MockClientInterface) UpdateServiceAccount(modified *v10.ServiceAccount) (*v10.ServiceAccount, error) {
	ret := m.ctrl.Call(m, "UpdateServiceAccount", modified)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteServiceAccount mocks base method
func (m *MockClientInterface) DeleteServiceAccount(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteServiceAccount", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

// DeleteRole mocks base method
func (m *MockClientInterface) DeleteRole(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteRole", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

// DeleteRoleBinding mocks base method
func (m *MockClientInterface) DeleteRoleBinding(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteRoleBinding", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeleteDeployment mocks base method
func (m *MockClientInterface) DeleteDeployment(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteDeployment", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UpdateDeployment mocks base method
func (m *MockClientInterface) UpdateDeployment(arg0 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "UpdateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// PatchDeployment mocks base method
func (m *MockClientInterface) PatchDeployment(arg0, arg1 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "PatchDeployment", arg0, arg1)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// RollingUpdateDeployment mocks base method
func (m *MockClientInterface) RollingUpdateDeployment(arg0 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingUpdateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// RollingPatchDeployment mocks base method
func (m *MockClientInterface) RollingPatchDeployment(arg0, arg1 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingPatchDeployment", arg0, arg1)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// RollingUpdateDeploymentMigrations mocks base method
func (m *MockClientInterface) RollingUpdateDeploymentMigrations(namespace, name string, f UpdateFunction) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingUpdateDeploymentMigrations", namespace, name, f)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// RollingPatchDeploymentMigrations mocks base method
func (m *MockClientInterface) RollingPatchDeploymentMigrations(namespace, name string, f PatchFunction) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingPatchDeploymentMigrations", namespace, name, f)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// CreateOrRollingUpdateDeployment mocks base method
func (m *MockClientInterface) CreateOrRollingUpdateDeployment(arg0 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "CreateOrRollingUpdateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// ListDeploymentsWithLabels mocks base method
func (m *MockClientInterface) ListDeploymentsWithLabels(namespace string, labels labels.Set) (*v1.DeploymentList, error) {
	ret := m.ctrl.Call(m, "ListDeploymentsWithLabels", namespace, labels)
	ret0, _ := ret[0].(*v1.DeploymentList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockCustomResourceClient is a mock of CustomResourceClient interface
type MockCustomResourceClient struct {
	ctrl     *gomock.Controller
	recorder *MockCustomResourceClientMockRecorder
}

// MockCustomResourceClientMockRecorder is the mock recorder for MockCustomResourceClient
type MockCustomResourceClientMockRecorder struct {
	mock *MockCustomResourceClient
}

// NewMockCustomResourceClient creates a new mock instance
func NewMockCustomResourceClient(ctrl *gomock.Controller) *MockCustomResourceClient {
	mock := &MockCustomResourceClient{ctrl: ctrl}
	mock.recorder = &MockCustomResourceClientMockRecorder{mock}
	return mock
}

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

// GetCustomResource mocks base method
func (m *MockCustomResourceClient) GetCustomResource(apiGroup, version, namespace, resourceKind, resourceName string) (*unstructured.Unstructured, error) {
	ret := m.ctrl.Call(m, "GetCustomResource", apiGroup, version, namespace, resourceKind, resourceName)
	ret0, _ := ret[0].(*unstructured.Unstructured)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomResource indicates an expected call of GetCustomResource
func (mr *MockCustomResourceClientMockRecorder) GetCustomResource(apiGroup, version, namespace, resourceKind, resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomResource", reflect.TypeOf((*MockCustomResourceClient)(nil).GetCustomResource), apiGroup, version, namespace, resourceKind, resourceName)
}

// GetCustomResourceRaw mocks base method
func (m *MockCustomResourceClient) GetCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName string) ([]byte, error) {
	ret := m.ctrl.Call(m, "GetCustomResourceRaw", apiGroup, version, namespace, resourceKind, resourceName)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCustomResourceRaw indicates an expected call of GetCustomResourceRaw
func (mr *MockCustomResourceClientMockRecorder) GetCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCustomResourceRaw", reflect.TypeOf((*MockCustomResourceClient)(nil).GetCustomResourceRaw), apiGroup, version, namespace, resourceKind, resourceName)
}

// CreateCustomResource mocks base method
func (m *MockCustomResourceClient) CreateCustomResource(item *unstructured.Unstructured) error {
	ret := m.ctrl.Call(m, "CreateCustomResource", item)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCustomResource indicates an expected call of CreateCustomResource
func (mr *MockCustomResourceClientMockRecorder) CreateCustomResource(item interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomResource", reflect.TypeOf((*MockCustomResourceClient)(nil).CreateCustomResource), item)
}

// CreateCustomResourceRaw mocks base method
func (m *MockCustomResourceClient) CreateCustomResourceRaw(apiGroup, version, namespace, kind string, data []byte) error {
	ret := m.ctrl.Call(m, "CreateCustomResourceRaw", apiGroup, version, namespace, kind, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCustomResourceRaw indicates an expected call of CreateCustomResourceRaw
func (mr *MockCustomResourceClientMockRecorder) CreateCustomResourceRaw(apiGroup, version, namespace, kind, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomResourceRaw", reflect.TypeOf((*MockCustomResourceClient)(nil).CreateCustomResourceRaw), apiGroup, version, namespace, kind, data)
}

// CreateCustomResourceRawIfNotFound mocks base method
func (m *MockCustomResourceClient) CreateCustomResourceRawIfNotFound(apiGroup, version, namespace, kind, name string, data []byte) (bool, error) {
	ret := m.ctrl.Call(m, "CreateCustomResourceRawIfNotFound", apiGroup, version, namespace, kind, name, data)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateCustomResourceRawIfNotFound indicates an expected call of CreateCustomResourceRawIfNotFound
func (mr *MockCustomResourceClientMockRecorder) CreateCustomResourceRawIfNotFound(apiGroup, version, namespace, kind, name, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomResourceRawIfNotFound", reflect.TypeOf((*MockCustomResourceClient)(nil).CreateCustomResourceRawIfNotFound), apiGroup, version, namespace, kind, name, data)
}

// UpdateCustomResource mocks base method
func (m *MockCustomResourceClient) UpdateCustomResource(item *unstructured.Unstructured) error {
	ret := m.ctrl.Call(m, "UpdateCustomResource", item)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCustomResource indicates an expected call of UpdateCustomResource
func (mr *MockCustomResourceClientMockRecorder) UpdateCustomResource(item interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomResource", reflect.TypeOf((*MockCustomResourceClient)(nil).UpdateCustomResource), item)
}

// UpdateCustomResourceRaw mocks base method
func (m *MockCustomResourceClient) UpdateCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName string, data []byte) error {
	ret := m.ctrl.Call(m, "UpdateCustomResourceRaw", apiGroup, version, namespace, resourceKind, resourceName, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateCustomResourceRaw indicates an expected call of UpdateCustomResourceRaw
func (mr *MockCustomResourceClientMockRecorder) UpdateCustomResourceRaw(apiGroup, version, namespace, resourceKind, resourceName, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCustomResourceRaw", reflect.TypeOf((*MockCustomResourceClient)(nil).UpdateCustomResourceRaw), apiGroup, version, namespace, resourceKind, resourceName, data)
}

// CreateOrUpdateCustomeResourceRaw mocks base method
func (m *MockCustomResourceClient) CreateOrUpdateCustomeResourceRaw(apiGroup, version, namespace, resourceKind, resourceName string, data []byte) error {
	ret := m.ctrl.Call(m, "CreateOrUpdateCustomeResourceRaw", apiGroup, version, namespace, resourceKind, resourceName, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateOrUpdateCustomeResourceRaw indicates an expected call of CreateOrUpdateCustomeResourceRaw
func (mr *MockCustomResourceClientMockRecorder) CreateOrUpdateCustomeResourceRaw(apiGroup, version, namespace, resourceKind, resourceName, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateCustomeResourceRaw", reflect.TypeOf((*MockCustomResourceClient)(nil).CreateOrUpdateCustomeResourceRaw), apiGroup, version, namespace, resourceKind, resourceName, data)
}

// DeleteCustomResource mocks base method
func (m *MockCustomResourceClient) DeleteCustomResource(apiGroup, version, namespace, resourceKind, resourceName string) error {
	ret := m.ctrl.Call(m, "DeleteCustomResource", apiGroup, version, namespace, resourceKind, resourceName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCustomResource indicates an expected call of DeleteCustomResource
func (mr *MockCustomResourceClientMockRecorder) DeleteCustomResource(apiGroup, version, namespace, resourceKind, resourceName interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomResource", reflect.TypeOf((*MockCustomResourceClient)(nil).DeleteCustomResource), apiGroup, version, namespace, resourceKind, resourceName)
}

// AtomicModifyCustomResource mocks base method
func (m *MockCustomResourceClient) AtomicModifyCustomResource(apiGroup, version, namespace, resourceKind, resourceName string, f CustomResourceModifier, data interface{}) error {
	ret := m.ctrl.Call(m, "AtomicModifyCustomResource", apiGroup, version, namespace, resourceKind, resourceName, f, data)
	ret0, _ := ret[0].(error)
	return ret0
}

// AtomicModifyCustomResource indicates an expected call of AtomicModifyCustomResource
func (mr *MockCustomResourceClientMockRecorder) AtomicModifyCustomResource(apiGroup, version, namespace, resourceKind, resourceName, f, data interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AtomicModifyCustomResource", reflect.TypeOf((*MockCustomResourceClient)(nil).AtomicModifyCustomResource), apiGroup, version, namespace, resourceKind, resourceName, f, data)
}

// ListCustomResource mocks base method
func (m *MockCustomResourceClient) ListCustomResource(apiGroup, version, namespace, resourceKind string) (*CustomResourceList, error) {
	ret := m.ctrl.Call(m, "ListCustomResource", apiGroup, version, namespace, resourceKind)
	ret0, _ := ret[0].(*CustomResourceList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCustomResource indicates an expected call of ListCustomResource
func (mr *MockCustomResourceClientMockRecorder) ListCustomResource(apiGroup, version, namespace, resourceKind interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomResource", reflect.TypeOf((*MockCustomResourceClient)(nil).ListCustomResource), apiGroup, version, namespace, resourceKind)
}

// MockAPIServiceClient is a mock of APIServiceClient interface
type MockAPIServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockAPIServiceClientMockRecorder
}

// MockAPIServiceClientMockRecorder is the mock recorder for MockAPIServiceClient
type MockAPIServiceClientMockRecorder struct {
	mock *MockAPIServiceClient
}

// NewMockAPIServiceClient creates a new mock instance
func NewMockAPIServiceClient(ctrl *gomock.Controller) *MockAPIServiceClient {
	mock := &MockAPIServiceClient{ctrl: ctrl}
	mock.recorder = &MockAPIServiceClientMockRecorder{mock}
	return mock
}

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

// CreateAPIService mocks base method
func (m *MockAPIServiceClient) CreateAPIService(arg0 *v13.APIService) (*v13.APIService, error) {
	ret := m.ctrl.Call(m, "CreateAPIService", arg0)
	ret0, _ := ret[0].(*v13.APIService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAPIService indicates an expected call of CreateAPIService
func (mr *MockAPIServiceClientMockRecorder) CreateAPIService(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAPIService", reflect.TypeOf((*MockAPIServiceClient)(nil).CreateAPIService), arg0)
}

// GetAPIService mocks base method
func (m *MockAPIServiceClient) GetAPIService(name string) (*v13.APIService, error) {
	ret := m.ctrl.Call(m, "GetAPIService", name)
	ret0, _ := ret[0].(*v13.APIService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAPIService indicates an expected call of GetAPIService
func (mr *MockAPIServiceClientMockRecorder) GetAPIService(name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPIService", reflect.TypeOf((*MockAPIServiceClient)(nil).GetAPIService), name)
}

// UpdateAPIService mocks base method
func (m *MockAPIServiceClient) UpdateAPIService(modified *v13.APIService) (*v13.APIService, error) {
	ret := m.ctrl.Call(m, "UpdateAPIService", modified)
	ret0, _ := ret[0].(*v13.APIService)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAPIService indicates an expected call of UpdateAPIService
func (mr *MockAPIServiceClientMockRecorder) UpdateAPIService(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAPIService", reflect.TypeOf((*MockAPIServiceClient)(nil).UpdateAPIService), modified)
}

// DeleteAPIService mocks base method
func (m *MockAPIServiceClient) DeleteAPIService(name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteAPIService", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAPIService indicates an expected call of DeleteAPIService
func (mr *MockAPIServiceClientMockRecorder) DeleteAPIService(name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAPIService", reflect.TypeOf((*MockAPIServiceClient)(nil).DeleteAPIService), name, options)
}

// MockSecretClient is a mock of SecretClient interface
type MockSecretClient struct {
	ctrl     *gomock.Controller
	recorder *MockSecretClientMockRecorder
}

// MockSecretClientMockRecorder is the mock recorder for MockSecretClient
type MockSecretClientMockRecorder struct {
	mock *MockSecretClient
}

// NewMockSecretClient creates a new mock instance
func NewMockSecretClient(ctrl *gomock.Controller) *MockSecretClient {
	mock := &MockSecretClient{ctrl: ctrl}
	mock.recorder = &MockSecretClientMockRecorder{mock}
	return mock
}

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

// CreateSecret mocks base method
func (m *MockSecretClient) CreateSecret(arg0 *v10.Secret) (*v10.Secret, error) {
	ret := m.ctrl.Call(m, "CreateSecret", arg0)
	ret0, _ := ret[0].(*v10.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSecret indicates an expected call of CreateSecret
func (mr *MockSecretClientMockRecorder) CreateSecret(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecret", reflect.TypeOf((*MockSecretClient)(nil).CreateSecret), arg0)
}

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

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

// UpdateSecret mocks base method
func (m *MockSecretClient) UpdateSecret(modified *v10.Secret) (*v10.Secret, error) {
	ret := m.ctrl.Call(m, "UpdateSecret", modified)
	ret0, _ := ret[0].(*v10.Secret)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateSecret indicates an expected call of UpdateSecret
func (mr *MockSecretClientMockRecorder) UpdateSecret(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecret", reflect.TypeOf((*MockSecretClient)(nil).UpdateSecret), modified)
}

// DeleteSecret mocks base method
func (m *MockSecretClient) DeleteSecret(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteSecret", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteSecret indicates an expected call of DeleteSecret
func (mr *MockSecretClientMockRecorder) DeleteSecret(namespace, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecret", reflect.TypeOf((*MockSecretClient)(nil).DeleteSecret), namespace, name, options)
}

// MockServiceClient is a mock of ServiceClient interface
type MockServiceClient struct {
	ctrl     *gomock.Controller
	recorder *MockServiceClientMockRecorder
}

// MockServiceClientMockRecorder is the mock recorder for MockServiceClient
type MockServiceClientMockRecorder struct {
	mock *MockServiceClient
}

// NewMockServiceClient creates a new mock instance
func NewMockServiceClient(ctrl *gomock.Controller) *MockServiceClient {
	mock := &MockServiceClient{ctrl: ctrl}
	mock.recorder = &MockServiceClientMockRecorder{mock}
	return mock
}

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

// CreateService mocks base method
func (m *MockServiceClient) CreateService(arg0 *v10.Service) (*v10.Service, error) {
	ret := m.ctrl.Call(m, "CreateService", arg0)
	ret0, _ := ret[0].(*v10.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateService indicates an expected call of CreateService
func (mr *MockServiceClientMockRecorder) CreateService(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateService", reflect.TypeOf((*MockServiceClient)(nil).CreateService), arg0)
}

// GetService mocks base method
func (m *MockServiceClient) GetService(namespace, name string) (*v10.Service, error) {
	ret := m.ctrl.Call(m, "GetService", namespace, name)
	ret0, _ := ret[0].(*v10.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetService indicates an expected call of GetService
func (mr *MockServiceClientMockRecorder) GetService(namespace, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetService", reflect.TypeOf((*MockServiceClient)(nil).GetService), namespace, name)
}

// UpdateService mocks base method
func (m *MockServiceClient) UpdateService(modified *v10.Service) (*v10.Service, error) {
	ret := m.ctrl.Call(m, "UpdateService", modified)
	ret0, _ := ret[0].(*v10.Service)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateService indicates an expected call of UpdateService
func (mr *MockServiceClientMockRecorder) UpdateService(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateService", reflect.TypeOf((*MockServiceClient)(nil).UpdateService), modified)
}

// DeleteService mocks base method
func (m *MockServiceClient) DeleteService(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteService", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteService indicates an expected call of DeleteService
func (mr *MockServiceClientMockRecorder) DeleteService(namespace, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteService", reflect.TypeOf((*MockServiceClient)(nil).DeleteService), namespace, name, options)
}

// MockServiceAccountClient is a mock of ServiceAccountClient interface
type MockServiceAccountClient struct {
	ctrl     *gomock.Controller
	recorder *MockServiceAccountClientMockRecorder
}

// MockServiceAccountClientMockRecorder is the mock recorder for MockServiceAccountClient
type MockServiceAccountClientMockRecorder struct {
	mock *MockServiceAccountClient
}

// NewMockServiceAccountClient creates a new mock instance
func NewMockServiceAccountClient(ctrl *gomock.Controller) *MockServiceAccountClient {
	mock := &MockServiceAccountClient{ctrl: ctrl}
	mock.recorder = &MockServiceAccountClientMockRecorder{mock}
	return mock
}

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

// CreateServiceAccount mocks base method
func (m *MockServiceAccountClient) CreateServiceAccount(arg0 *v10.ServiceAccount) (*v10.ServiceAccount, error) {
	ret := m.ctrl.Call(m, "CreateServiceAccount", arg0)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateServiceAccount indicates an expected call of CreateServiceAccount
func (mr *MockServiceAccountClientMockRecorder) CreateServiceAccount(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).CreateServiceAccount), arg0)
}

// GetServiceAccount mocks base method
func (m *MockServiceAccountClient) GetServiceAccount(namespace, name string) (*v10.ServiceAccount, error) {
	ret := m.ctrl.Call(m, "GetServiceAccount", namespace, name)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetServiceAccount indicates an expected call of GetServiceAccount
func (mr *MockServiceAccountClientMockRecorder) GetServiceAccount(namespace, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).GetServiceAccount), namespace, name)
}

// UpdateServiceAccount mocks base method
func (m *MockServiceAccountClient) UpdateServiceAccount(modified *v10.ServiceAccount) (*v10.ServiceAccount, error) {
	ret := m.ctrl.Call(m, "UpdateServiceAccount", modified)
	ret0, _ := ret[0].(*v10.ServiceAccount)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateServiceAccount indicates an expected call of UpdateServiceAccount
func (mr *MockServiceAccountClientMockRecorder) UpdateServiceAccount(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).UpdateServiceAccount), modified)
}

// DeleteServiceAccount mocks base method
func (m *MockServiceAccountClient) DeleteServiceAccount(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteServiceAccount", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteServiceAccount indicates an expected call of DeleteServiceAccount
func (mr *MockServiceAccountClientMockRecorder) DeleteServiceAccount(namespace, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteServiceAccount", reflect.TypeOf((*MockServiceAccountClient)(nil).DeleteServiceAccount), namespace, name, options)
}

// MockRoleClient is a mock of RoleClient interface
type MockRoleClient struct {
	ctrl     *gomock.Controller
	recorder *MockRoleClientMockRecorder
}

// MockRoleClientMockRecorder is the mock recorder for MockRoleClient
type MockRoleClientMockRecorder struct {
	mock *MockRoleClient
}

// NewMockRoleClient creates a new mock instance
func NewMockRoleClient(ctrl *gomock.Controller) *MockRoleClient {
	mock := &MockRoleClient{ctrl: ctrl}
	mock.recorder = &MockRoleClientMockRecorder{mock}
	return mock
}

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

// CreateRole mocks base method
func (m *MockRoleClient) CreateRole(arg0 *v11.Role) (*v11.Role, error) {
	ret := m.ctrl.Call(m, "CreateRole", arg0)
	ret0, _ := ret[0].(*v11.Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRole indicates an expected call of CreateRole
func (mr *MockRoleClientMockRecorder) CreateRole(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRole", reflect.TypeOf((*MockRoleClient)(nil).CreateRole), arg0)
}

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

// GetRole indicates an expected call of GetRole
func (mr *MockRoleClientMockRecorder) GetRole(namespace, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRole", reflect.TypeOf((*MockRoleClient)(nil).GetRole), namespace, name)
}

// UpdateRole mocks base method
func (m *MockRoleClient) UpdateRole(modified *v11.Role) (*v11.Role, error) {
	ret := m.ctrl.Call(m, "UpdateRole", modified)
	ret0, _ := ret[0].(*v11.Role)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRole indicates an expected call of UpdateRole
func (mr *MockRoleClientMockRecorder) UpdateRole(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRole", reflect.TypeOf((*MockRoleClient)(nil).UpdateRole), modified)
}

// DeleteRole mocks base method
func (m *MockRoleClient) DeleteRole(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteRole", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRole indicates an expected call of DeleteRole
func (mr *MockRoleClientMockRecorder) DeleteRole(namespace, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRole", reflect.TypeOf((*MockRoleClient)(nil).DeleteRole), namespace, name, options)
}

// MockRoleBindingClient is a mock of RoleBindingClient interface
type MockRoleBindingClient struct {
	ctrl     *gomock.Controller
	recorder *MockRoleBindingClientMockRecorder
}

// MockRoleBindingClientMockRecorder is the mock recorder for MockRoleBindingClient
type MockRoleBindingClientMockRecorder struct {
	mock *MockRoleBindingClient
}

// NewMockRoleBindingClient creates a new mock instance
func NewMockRoleBindingClient(ctrl *gomock.Controller) *MockRoleBindingClient {
	mock := &MockRoleBindingClient{ctrl: ctrl}
	mock.recorder = &MockRoleBindingClientMockRecorder{mock}
	return mock
}

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

// CreateRoleBinding mocks base method
func (m *MockRoleBindingClient) CreateRoleBinding(arg0 *v11.RoleBinding) (*v11.RoleBinding, error) {
	ret := m.ctrl.Call(m, "CreateRoleBinding", arg0)
	ret0, _ := ret[0].(*v11.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRoleBinding indicates an expected call of CreateRoleBinding
func (mr *MockRoleBindingClientMockRecorder) CreateRoleBinding(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoleBinding", reflect.TypeOf((*MockRoleBindingClient)(nil).CreateRoleBinding), arg0)
}

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

// GetRoleBinding indicates an expected call of GetRoleBinding
func (mr *MockRoleBindingClientMockRecorder) GetRoleBinding(namespace, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRoleBinding", reflect.TypeOf((*MockRoleBindingClient)(nil).GetRoleBinding), namespace, name)
}

// UpdateRoleBinding mocks base method
func (m *MockRoleBindingClient) UpdateRoleBinding(modified *v11.RoleBinding) (*v11.RoleBinding, error) {
	ret := m.ctrl.Call(m, "UpdateRoleBinding", modified)
	ret0, _ := ret[0].(*v11.RoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateRoleBinding indicates an expected call of UpdateRoleBinding
func (mr *MockRoleBindingClientMockRecorder) UpdateRoleBinding(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRoleBinding", reflect.TypeOf((*MockRoleBindingClient)(nil).UpdateRoleBinding), modified)
}

// DeleteRoleBinding mocks base method
func (m *MockRoleBindingClient) DeleteRoleBinding(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteRoleBinding", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteRoleBinding indicates an expected call of DeleteRoleBinding
func (mr *MockRoleBindingClientMockRecorder) DeleteRoleBinding(namespace, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoleBinding", reflect.TypeOf((*MockRoleBindingClient)(nil).DeleteRoleBinding), namespace, name, options)
}

// MockClusterRoleClient is a mock of ClusterRoleClient interface
type MockClusterRoleClient struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleClientMockRecorder
}

// MockClusterRoleClientMockRecorder is the mock recorder for MockClusterRoleClient
type MockClusterRoleClientMockRecorder struct {
	mock *MockClusterRoleClient
}

// NewMockClusterRoleClient creates a new mock instance
func NewMockClusterRoleClient(ctrl *gomock.Controller) *MockClusterRoleClient {
	mock := &MockClusterRoleClient{ctrl: ctrl}
	mock.recorder = &MockClusterRoleClientMockRecorder{mock}
	return mock
}

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

// CreateClusterRole mocks base method
func (m *MockClusterRoleClient) CreateClusterRole(arg0 *v11.ClusterRole) (*v11.ClusterRole, error) {
	ret := m.ctrl.Call(m, "CreateClusterRole", arg0)
	ret0, _ := ret[0].(*v11.ClusterRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClusterRole indicates an expected call of CreateClusterRole
func (mr *MockClusterRoleClientMockRecorder) CreateClusterRole(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterRole", reflect.TypeOf((*MockClusterRoleClient)(nil).CreateClusterRole), arg0)
}

// GetClusterRole mocks base method
func (m *MockClusterRoleClient) GetClusterRole(name string) (*v11.ClusterRole, error) {
	ret := m.ctrl.Call(m, "GetClusterRole", name)
	ret0, _ := ret[0].(*v11.ClusterRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterRole indicates an expected call of GetClusterRole
func (mr *MockClusterRoleClientMockRecorder) GetClusterRole(name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterRole", reflect.TypeOf((*MockClusterRoleClient)(nil).GetClusterRole), name)
}

// UpdateClusterRole mocks base method
func (m *MockClusterRoleClient) UpdateClusterRole(modified *v11.ClusterRole) (*v11.ClusterRole, error) {
	ret := m.ctrl.Call(m, "UpdateClusterRole", modified)
	ret0, _ := ret[0].(*v11.ClusterRole)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterRole indicates an expected call of UpdateClusterRole
func (mr *MockClusterRoleClientMockRecorder) UpdateClusterRole(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterRole", reflect.TypeOf((*MockClusterRoleClient)(nil).UpdateClusterRole), modified)
}

// DeleteClusterRole mocks base method
func (m *MockClusterRoleClient) DeleteClusterRole(name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteClusterRole", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteClusterRole indicates an expected call of DeleteClusterRole
func (mr *MockClusterRoleClientMockRecorder) DeleteClusterRole(name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterRole", reflect.TypeOf((*MockClusterRoleClient)(nil).DeleteClusterRole), name, options)
}

// MockClusterRoleBindingClient is a mock of ClusterRoleBindingClient interface
type MockClusterRoleBindingClient struct {
	ctrl     *gomock.Controller
	recorder *MockClusterRoleBindingClientMockRecorder
}

// MockClusterRoleBindingClientMockRecorder is the mock recorder for MockClusterRoleBindingClient
type MockClusterRoleBindingClientMockRecorder struct {
	mock *MockClusterRoleBindingClient
}

// NewMockClusterRoleBindingClient creates a new mock instance
func NewMockClusterRoleBindingClient(ctrl *gomock.Controller) *MockClusterRoleBindingClient {
	mock := &MockClusterRoleBindingClient{ctrl: ctrl}
	mock.recorder = &MockClusterRoleBindingClientMockRecorder{mock}
	return mock
}

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

// CreateClusterRoleBinding mocks base method
func (m *MockClusterRoleBindingClient) CreateClusterRoleBinding(arg0 *v11.ClusterRoleBinding) (*v11.ClusterRoleBinding, error) {
	ret := m.ctrl.Call(m, "CreateClusterRoleBinding", arg0)
	ret0, _ := ret[0].(*v11.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateClusterRoleBinding indicates an expected call of CreateClusterRoleBinding
func (mr *MockClusterRoleBindingClientMockRecorder) CreateClusterRoleBinding(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingClient)(nil).CreateClusterRoleBinding), arg0)
}

// GetClusterRoleBinding mocks base method
func (m *MockClusterRoleBindingClient) GetClusterRoleBinding(name string) (*v11.ClusterRoleBinding, error) {
	ret := m.ctrl.Call(m, "GetClusterRoleBinding", name)
	ret0, _ := ret[0].(*v11.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterRoleBinding indicates an expected call of GetClusterRoleBinding
func (mr *MockClusterRoleBindingClientMockRecorder) GetClusterRoleBinding(name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingClient)(nil).GetClusterRoleBinding), name)
}

// UpdateClusterRoleBinding mocks base method
func (m *MockClusterRoleBindingClient) UpdateClusterRoleBinding(modified *v11.ClusterRoleBinding) (*v11.ClusterRoleBinding, error) {
	ret := m.ctrl.Call(m, "UpdateClusterRoleBinding", modified)
	ret0, _ := ret[0].(*v11.ClusterRoleBinding)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateClusterRoleBinding indicates an expected call of UpdateClusterRoleBinding
func (mr *MockClusterRoleBindingClientMockRecorder) UpdateClusterRoleBinding(modified interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingClient)(nil).UpdateClusterRoleBinding), modified)
}

// DeleteClusterRoleBinding mocks base method
func (m *MockClusterRoleBindingClient) DeleteClusterRoleBinding(name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteClusterRoleBinding", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteClusterRoleBinding indicates an expected call of DeleteClusterRoleBinding
func (mr *MockClusterRoleBindingClientMockRecorder) DeleteClusterRoleBinding(name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClusterRoleBinding", reflect.TypeOf((*MockClusterRoleBindingClient)(nil).DeleteClusterRoleBinding), name, options)
}

// MockDeploymentClient is a mock of DeploymentClient interface
type MockDeploymentClient struct {
	ctrl     *gomock.Controller
	recorder *MockDeploymentClientMockRecorder
}

// MockDeploymentClientMockRecorder is the mock recorder for MockDeploymentClient
type MockDeploymentClientMockRecorder struct {
	mock *MockDeploymentClient
}

// NewMockDeploymentClient creates a new mock instance
func NewMockDeploymentClient(ctrl *gomock.Controller) *MockDeploymentClient {
	mock := &MockDeploymentClient{ctrl: ctrl}
	mock.recorder = &MockDeploymentClientMockRecorder{mock}
	return mock
}

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

// GetDeployment mocks base method
func (m *MockDeploymentClient) GetDeployment(namespace, name string) (*v1.Deployment, error) {
	ret := m.ctrl.Call(m, "GetDeployment", namespace, name)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeployment indicates an expected call of GetDeployment
func (mr *MockDeploymentClientMockRecorder) GetDeployment(namespace, name interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).GetDeployment), namespace, name)
}

// CreateDeployment mocks base method
func (m *MockDeploymentClient) CreateDeployment(arg0 *v1.Deployment) (*v1.Deployment, error) {
	ret := m.ctrl.Call(m, "CreateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDeployment indicates an expected call of CreateDeployment
func (mr *MockDeploymentClientMockRecorder) CreateDeployment(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).CreateDeployment), arg0)
}

// DeleteDeployment mocks base method
func (m *MockDeploymentClient) DeleteDeployment(namespace, name string, options *v12.DeleteOptions) error {
	ret := m.ctrl.Call(m, "DeleteDeployment", namespace, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDeployment indicates an expected call of DeleteDeployment
func (mr *MockDeploymentClientMockRecorder) DeleteDeployment(namespace, name, options interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).DeleteDeployment), namespace, name, options)
}

// UpdateDeployment mocks base method
func (m *MockDeploymentClient) UpdateDeployment(arg0 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "UpdateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// UpdateDeployment indicates an expected call of UpdateDeployment
func (mr *MockDeploymentClientMockRecorder) UpdateDeployment(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).UpdateDeployment), arg0)
}

// PatchDeployment mocks base method
func (m *MockDeploymentClient) PatchDeployment(arg0, arg1 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "PatchDeployment", arg0, arg1)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// PatchDeployment indicates an expected call of PatchDeployment
func (mr *MockDeploymentClientMockRecorder) PatchDeployment(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PatchDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).PatchDeployment), arg0, arg1)
}

// RollingUpdateDeployment mocks base method
func (m *MockDeploymentClient) RollingUpdateDeployment(arg0 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingUpdateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RollingUpdateDeployment indicates an expected call of RollingUpdateDeployment
func (mr *MockDeploymentClientMockRecorder) RollingUpdateDeployment(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollingUpdateDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).RollingUpdateDeployment), arg0)
}

// RollingPatchDeployment mocks base method
func (m *MockDeploymentClient) RollingPatchDeployment(arg0, arg1 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingPatchDeployment", arg0, arg1)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RollingPatchDeployment indicates an expected call of RollingPatchDeployment
func (mr *MockDeploymentClientMockRecorder) RollingPatchDeployment(arg0, arg1 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollingPatchDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).RollingPatchDeployment), arg0, arg1)
}

// RollingUpdateDeploymentMigrations mocks base method
func (m *MockDeploymentClient) RollingUpdateDeploymentMigrations(namespace, name string, f UpdateFunction) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingUpdateDeploymentMigrations", namespace, name, f)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RollingUpdateDeploymentMigrations indicates an expected call of RollingUpdateDeploymentMigrations
func (mr *MockDeploymentClientMockRecorder) RollingUpdateDeploymentMigrations(namespace, name, f interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollingUpdateDeploymentMigrations", reflect.TypeOf((*MockDeploymentClient)(nil).RollingUpdateDeploymentMigrations), namespace, name, f)
}

// RollingPatchDeploymentMigrations mocks base method
func (m *MockDeploymentClient) RollingPatchDeploymentMigrations(namespace, name string, f PatchFunction) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "RollingPatchDeploymentMigrations", namespace, name, f)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// RollingPatchDeploymentMigrations indicates an expected call of RollingPatchDeploymentMigrations
func (mr *MockDeploymentClientMockRecorder) RollingPatchDeploymentMigrations(namespace, name, f interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RollingPatchDeploymentMigrations", reflect.TypeOf((*MockDeploymentClient)(nil).RollingPatchDeploymentMigrations), namespace, name, f)
}

// CreateOrRollingUpdateDeployment mocks base method
func (m *MockDeploymentClient) CreateOrRollingUpdateDeployment(arg0 *v1.Deployment) (*v1.Deployment, bool, error) {
	ret := m.ctrl.Call(m, "CreateOrRollingUpdateDeployment", arg0)
	ret0, _ := ret[0].(*v1.Deployment)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateOrRollingUpdateDeployment indicates an expected call of CreateOrRollingUpdateDeployment
func (mr *MockDeploymentClientMockRecorder) CreateOrRollingUpdateDeployment(arg0 interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrRollingUpdateDeployment", reflect.TypeOf((*MockDeploymentClient)(nil).CreateOrRollingUpdateDeployment), arg0)
}

// ListDeploymentsWithLabels mocks base method
func (m *MockDeploymentClient) ListDeploymentsWithLabels(namespace string, labels labels.Set) (*v1.DeploymentList, error) {
	ret := m.ctrl.Call(m, "ListDeploymentsWithLabels", namespace, labels)
	ret0, _ := ret[0].(*v1.DeploymentList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDeploymentsWithLabels indicates an expected call of ListDeploymentsWithLabels
func (mr *MockDeploymentClientMockRecorder) ListDeploymentsWithLabels(namespace, labels interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDeploymentsWithLabels", reflect.TypeOf((*MockDeploymentClient)(nil).ListDeploymentsWithLabels), namespace, labels)
}
