// Automatically generated by MockGen. DO NOT EDIT!
// Source: kubevirt.go

package kubecli

import (
	time "time"

	gomock "github.com/golang/mock/gomock"
	versioned "github.com/k8snetworkplumbingwg/network-attachment-definition-client/pkg/client/clientset/versioned"
	v1 "github.com/openshift/client-go/security/clientset/versioned/typed/security/v1"
	v10 "k8s.io/api/autoscaling/v1"
	clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
	v11 "k8s.io/apimachinery/pkg/apis/meta/v1"
	types "k8s.io/apimachinery/pkg/types"
	discovery "k8s.io/client-go/discovery"
	v1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1"
	v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1"
	v12 "k8s.io/client-go/kubernetes/typed/apps/v1"
	v1beta10 "k8s.io/client-go/kubernetes/typed/apps/v1beta1"
	v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2"
	v1alpha10 "k8s.io/client-go/kubernetes/typed/auditregistration/v1alpha1"
	v13 "k8s.io/client-go/kubernetes/typed/authentication/v1"
	v1beta11 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
	v14 "k8s.io/client-go/kubernetes/typed/authorization/v1"
	v1beta12 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
	v15 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
	v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1"
	v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2"
	v16 "k8s.io/client-go/kubernetes/typed/batch/v1"
	v1beta13 "k8s.io/client-go/kubernetes/typed/batch/v1beta1"
	v2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1"
	v1beta14 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
	v1beta15 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1"
	v17 "k8s.io/client-go/kubernetes/typed/core/v1"
	v1beta16 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
	v1beta17 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
	v18 "k8s.io/client-go/kubernetes/typed/networking/v1"
	v1beta18 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
	v19 "k8s.io/client-go/kubernetes/typed/rbac/v1"
	v1alpha11 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
	v1beta19 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
	v1alpha12 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
	v1beta110 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
	v1alpha13 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1"
	v110 "k8s.io/client-go/kubernetes/typed/storage/v1"
	v1alpha14 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1"
	v1beta111 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
	rest "k8s.io/client-go/rest"

	v111 "kubevirt.io/client-go/api/v1"
	versioned0 "kubevirt.io/containerized-data-importer/pkg/client/clientset/versioned"
)

// Mock of KubevirtClient interface
type MockKubevirtClient struct {
	ctrl     *gomock.Controller
	recorder *_MockKubevirtClientRecorder
}

// Recorder for MockKubevirtClient (not exported)
type _MockKubevirtClientRecorder struct {
	mock *MockKubevirtClient
}

func NewMockKubevirtClient(ctrl *gomock.Controller) *MockKubevirtClient {
	mock := &MockKubevirtClient{ctrl: ctrl}
	mock.recorder = &_MockKubevirtClientRecorder{mock}
	return mock
}

func (_m *MockKubevirtClient) EXPECT() *_MockKubevirtClientRecorder {
	return _m.recorder
}

func (_m *MockKubevirtClient) VirtualMachineInstance(namespace string) VirtualMachineInstanceInterface {
	ret := _m.ctrl.Call(_m, "VirtualMachineInstance", namespace)
	ret0, _ := ret[0].(VirtualMachineInstanceInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstance(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstance", arg0)
}

func (_m *MockKubevirtClient) VirtualMachineInstanceMigration(namespace string) VirtualMachineInstanceMigrationInterface {
	ret := _m.ctrl.Call(_m, "VirtualMachineInstanceMigration", namespace)
	ret0, _ := ret[0].(VirtualMachineInstanceMigrationInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstanceMigration(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstanceMigration", arg0)
}

func (_m *MockKubevirtClient) ReplicaSet(namespace string) ReplicaSetInterface {
	ret := _m.ctrl.Call(_m, "ReplicaSet", namespace)
	ret0, _ := ret[0].(ReplicaSetInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) ReplicaSet(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ReplicaSet", arg0)
}

func (_m *MockKubevirtClient) VirtualMachine(namespace string) VirtualMachineInterface {
	ret := _m.ctrl.Call(_m, "VirtualMachine", namespace)
	ret0, _ := ret[0].(VirtualMachineInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) VirtualMachine(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachine", arg0)
}

func (_m *MockKubevirtClient) KubeVirt(namespace string) KubeVirtInterface {
	ret := _m.ctrl.Call(_m, "KubeVirt", namespace)
	ret0, _ := ret[0].(KubeVirtInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) KubeVirt(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "KubeVirt", arg0)
}

func (_m *MockKubevirtClient) VirtualMachineInstancePreset(namespace string) VirtualMachineInstancePresetInterface {
	ret := _m.ctrl.Call(_m, "VirtualMachineInstancePreset", namespace)
	ret0, _ := ret[0].(VirtualMachineInstancePresetInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) VirtualMachineInstancePreset(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachineInstancePreset", arg0)
}

func (_m *MockKubevirtClient) ServerVersion() *ServerVersion {
	ret := _m.ctrl.Call(_m, "ServerVersion")
	ret0, _ := ret[0].(*ServerVersion)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) ServerVersion() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ServerVersion")
}

func (_m *MockKubevirtClient) RestClient() *rest.RESTClient {
	ret := _m.ctrl.Call(_m, "RestClient")
	ret0, _ := ret[0].(*rest.RESTClient)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) RestClient() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RestClient")
}

func (_m *MockKubevirtClient) CdiClient() versioned0.Interface {
	ret := _m.ctrl.Call(_m, "CdiClient")
	ret0, _ := ret[0].(versioned0.Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) CdiClient() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CdiClient")
}

func (_m *MockKubevirtClient) NetworkClient() versioned.Interface {
	ret := _m.ctrl.Call(_m, "NetworkClient")
	ret0, _ := ret[0].(versioned.Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) NetworkClient() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "NetworkClient")
}

func (_m *MockKubevirtClient) ExtensionsClient() clientset.Interface {
	ret := _m.ctrl.Call(_m, "ExtensionsClient")
	ret0, _ := ret[0].(clientset.Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) ExtensionsClient() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ExtensionsClient")
}

func (_m *MockKubevirtClient) SecClient() v1.SecurityV1Interface {
	ret := _m.ctrl.Call(_m, "SecClient")
	ret0, _ := ret[0].(v1.SecurityV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) SecClient() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SecClient")
}

func (_m *MockKubevirtClient) DiscoveryClient() discovery.DiscoveryInterface {
	ret := _m.ctrl.Call(_m, "DiscoveryClient")
	ret0, _ := ret[0].(discovery.DiscoveryInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) DiscoveryClient() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "DiscoveryClient")
}

func (_m *MockKubevirtClient) Discovery() discovery.DiscoveryInterface {
	ret := _m.ctrl.Call(_m, "Discovery")
	ret0, _ := ret[0].(discovery.DiscoveryInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Discovery() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Discovery")
}

func (_m *MockKubevirtClient) AdmissionregistrationV1alpha1() v1alpha1.AdmissionregistrationV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "AdmissionregistrationV1alpha1")
	ret0, _ := ret[0].(v1alpha1.AdmissionregistrationV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AdmissionregistrationV1alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AdmissionregistrationV1alpha1")
}

func (_m *MockKubevirtClient) AdmissionregistrationV1beta1() v1beta1.AdmissionregistrationV1beta1Interface {
	ret := _m.ctrl.Call(_m, "AdmissionregistrationV1beta1")
	ret0, _ := ret[0].(v1beta1.AdmissionregistrationV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AdmissionregistrationV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AdmissionregistrationV1beta1")
}

func (_m *MockKubevirtClient) Admissionregistration() v1beta1.AdmissionregistrationV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Admissionregistration")
	ret0, _ := ret[0].(v1beta1.AdmissionregistrationV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Admissionregistration() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Admissionregistration")
}

func (_m *MockKubevirtClient) AppsV1beta1() v1beta10.AppsV1beta1Interface {
	ret := _m.ctrl.Call(_m, "AppsV1beta1")
	ret0, _ := ret[0].(v1beta10.AppsV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AppsV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AppsV1beta1")
}

func (_m *MockKubevirtClient) AppsV1beta2() v1beta2.AppsV1beta2Interface {
	ret := _m.ctrl.Call(_m, "AppsV1beta2")
	ret0, _ := ret[0].(v1beta2.AppsV1beta2Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AppsV1beta2() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AppsV1beta2")
}

func (_m *MockKubevirtClient) AppsV1() v12.AppsV1Interface {
	ret := _m.ctrl.Call(_m, "AppsV1")
	ret0, _ := ret[0].(v12.AppsV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AppsV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AppsV1")
}

func (_m *MockKubevirtClient) Apps() v12.AppsV1Interface {
	ret := _m.ctrl.Call(_m, "Apps")
	ret0, _ := ret[0].(v12.AppsV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Apps() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Apps")
}

func (_m *MockKubevirtClient) AuditregistrationV1alpha1() v1alpha10.AuditregistrationV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "AuditregistrationV1alpha1")
	ret0, _ := ret[0].(v1alpha10.AuditregistrationV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AuditregistrationV1alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AuditregistrationV1alpha1")
}

func (_m *MockKubevirtClient) Auditregistration() v1alpha10.AuditregistrationV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "Auditregistration")
	ret0, _ := ret[0].(v1alpha10.AuditregistrationV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Auditregistration() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Auditregistration")
}

func (_m *MockKubevirtClient) AuthenticationV1() v13.AuthenticationV1Interface {
	ret := _m.ctrl.Call(_m, "AuthenticationV1")
	ret0, _ := ret[0].(v13.AuthenticationV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AuthenticationV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthenticationV1")
}

func (_m *MockKubevirtClient) Authentication() v13.AuthenticationV1Interface {
	ret := _m.ctrl.Call(_m, "Authentication")
	ret0, _ := ret[0].(v13.AuthenticationV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Authentication() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Authentication")
}

func (_m *MockKubevirtClient) AuthenticationV1beta1() v1beta11.AuthenticationV1beta1Interface {
	ret := _m.ctrl.Call(_m, "AuthenticationV1beta1")
	ret0, _ := ret[0].(v1beta11.AuthenticationV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AuthenticationV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthenticationV1beta1")
}

func (_m *MockKubevirtClient) AuthorizationV1() v14.AuthorizationV1Interface {
	ret := _m.ctrl.Call(_m, "AuthorizationV1")
	ret0, _ := ret[0].(v14.AuthorizationV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AuthorizationV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthorizationV1")
}

func (_m *MockKubevirtClient) Authorization() v14.AuthorizationV1Interface {
	ret := _m.ctrl.Call(_m, "Authorization")
	ret0, _ := ret[0].(v14.AuthorizationV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Authorization() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Authorization")
}

func (_m *MockKubevirtClient) AuthorizationV1beta1() v1beta12.AuthorizationV1beta1Interface {
	ret := _m.ctrl.Call(_m, "AuthorizationV1beta1")
	ret0, _ := ret[0].(v1beta12.AuthorizationV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AuthorizationV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AuthorizationV1beta1")
}

func (_m *MockKubevirtClient) AutoscalingV1() v15.AutoscalingV1Interface {
	ret := _m.ctrl.Call(_m, "AutoscalingV1")
	ret0, _ := ret[0].(v15.AutoscalingV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AutoscalingV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV1")
}

func (_m *MockKubevirtClient) Autoscaling() v15.AutoscalingV1Interface {
	ret := _m.ctrl.Call(_m, "Autoscaling")
	ret0, _ := ret[0].(v15.AutoscalingV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Autoscaling() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Autoscaling")
}

func (_m *MockKubevirtClient) AutoscalingV2beta1() v2beta1.AutoscalingV2beta1Interface {
	ret := _m.ctrl.Call(_m, "AutoscalingV2beta1")
	ret0, _ := ret[0].(v2beta1.AutoscalingV2beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AutoscalingV2beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV2beta1")
}

func (_m *MockKubevirtClient) AutoscalingV2beta2() v2beta2.AutoscalingV2beta2Interface {
	ret := _m.ctrl.Call(_m, "AutoscalingV2beta2")
	ret0, _ := ret[0].(v2beta2.AutoscalingV2beta2Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) AutoscalingV2beta2() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "AutoscalingV2beta2")
}

func (_m *MockKubevirtClient) BatchV1() v16.BatchV1Interface {
	ret := _m.ctrl.Call(_m, "BatchV1")
	ret0, _ := ret[0].(v16.BatchV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) BatchV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchV1")
}

func (_m *MockKubevirtClient) Batch() v16.BatchV1Interface {
	ret := _m.ctrl.Call(_m, "Batch")
	ret0, _ := ret[0].(v16.BatchV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Batch() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Batch")
}

func (_m *MockKubevirtClient) BatchV1beta1() v1beta13.BatchV1beta1Interface {
	ret := _m.ctrl.Call(_m, "BatchV1beta1")
	ret0, _ := ret[0].(v1beta13.BatchV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) BatchV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchV1beta1")
}

func (_m *MockKubevirtClient) BatchV2alpha1() v2alpha1.BatchV2alpha1Interface {
	ret := _m.ctrl.Call(_m, "BatchV2alpha1")
	ret0, _ := ret[0].(v2alpha1.BatchV2alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) BatchV2alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "BatchV2alpha1")
}

func (_m *MockKubevirtClient) CertificatesV1beta1() v1beta14.CertificatesV1beta1Interface {
	ret := _m.ctrl.Call(_m, "CertificatesV1beta1")
	ret0, _ := ret[0].(v1beta14.CertificatesV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) CertificatesV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CertificatesV1beta1")
}

func (_m *MockKubevirtClient) Certificates() v1beta14.CertificatesV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Certificates")
	ret0, _ := ret[0].(v1beta14.CertificatesV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Certificates() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Certificates")
}

func (_m *MockKubevirtClient) CoordinationV1beta1() v1beta15.CoordinationV1beta1Interface {
	ret := _m.ctrl.Call(_m, "CoordinationV1beta1")
	ret0, _ := ret[0].(v1beta15.CoordinationV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) CoordinationV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CoordinationV1beta1")
}

func (_m *MockKubevirtClient) Coordination() v1beta15.CoordinationV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Coordination")
	ret0, _ := ret[0].(v1beta15.CoordinationV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Coordination() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Coordination")
}

func (_m *MockKubevirtClient) CoreV1() v17.CoreV1Interface {
	ret := _m.ctrl.Call(_m, "CoreV1")
	ret0, _ := ret[0].(v17.CoreV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) CoreV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "CoreV1")
}

func (_m *MockKubevirtClient) Core() v17.CoreV1Interface {
	ret := _m.ctrl.Call(_m, "Core")
	ret0, _ := ret[0].(v17.CoreV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Core() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Core")
}

func (_m *MockKubevirtClient) EventsV1beta1() v1beta16.EventsV1beta1Interface {
	ret := _m.ctrl.Call(_m, "EventsV1beta1")
	ret0, _ := ret[0].(v1beta16.EventsV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) EventsV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "EventsV1beta1")
}

func (_m *MockKubevirtClient) Events() v1beta16.EventsV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Events")
	ret0, _ := ret[0].(v1beta16.EventsV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Events() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Events")
}

func (_m *MockKubevirtClient) ExtensionsV1beta1() v1beta17.ExtensionsV1beta1Interface {
	ret := _m.ctrl.Call(_m, "ExtensionsV1beta1")
	ret0, _ := ret[0].(v1beta17.ExtensionsV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) ExtensionsV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "ExtensionsV1beta1")
}

func (_m *MockKubevirtClient) Extensions() v1beta17.ExtensionsV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Extensions")
	ret0, _ := ret[0].(v1beta17.ExtensionsV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Extensions() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Extensions")
}

func (_m *MockKubevirtClient) NetworkingV1() v18.NetworkingV1Interface {
	ret := _m.ctrl.Call(_m, "NetworkingV1")
	ret0, _ := ret[0].(v18.NetworkingV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) NetworkingV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "NetworkingV1")
}

func (_m *MockKubevirtClient) Networking() v18.NetworkingV1Interface {
	ret := _m.ctrl.Call(_m, "Networking")
	ret0, _ := ret[0].(v18.NetworkingV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Networking() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Networking")
}

func (_m *MockKubevirtClient) PolicyV1beta1() v1beta18.PolicyV1beta1Interface {
	ret := _m.ctrl.Call(_m, "PolicyV1beta1")
	ret0, _ := ret[0].(v1beta18.PolicyV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) PolicyV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "PolicyV1beta1")
}

func (_m *MockKubevirtClient) Policy() v1beta18.PolicyV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Policy")
	ret0, _ := ret[0].(v1beta18.PolicyV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Policy() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Policy")
}

func (_m *MockKubevirtClient) RbacV1() v19.RbacV1Interface {
	ret := _m.ctrl.Call(_m, "RbacV1")
	ret0, _ := ret[0].(v19.RbacV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) RbacV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RbacV1")
}

func (_m *MockKubevirtClient) Rbac() v19.RbacV1Interface {
	ret := _m.ctrl.Call(_m, "Rbac")
	ret0, _ := ret[0].(v19.RbacV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Rbac() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Rbac")
}

func (_m *MockKubevirtClient) RbacV1beta1() v1beta19.RbacV1beta1Interface {
	ret := _m.ctrl.Call(_m, "RbacV1beta1")
	ret0, _ := ret[0].(v1beta19.RbacV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) RbacV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RbacV1beta1")
}

func (_m *MockKubevirtClient) RbacV1alpha1() v1alpha11.RbacV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "RbacV1alpha1")
	ret0, _ := ret[0].(v1alpha11.RbacV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) RbacV1alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "RbacV1alpha1")
}

func (_m *MockKubevirtClient) SchedulingV1alpha1() v1alpha12.SchedulingV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "SchedulingV1alpha1")
	ret0, _ := ret[0].(v1alpha12.SchedulingV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) SchedulingV1alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SchedulingV1alpha1")
}

func (_m *MockKubevirtClient) SchedulingV1beta1() v1beta110.SchedulingV1beta1Interface {
	ret := _m.ctrl.Call(_m, "SchedulingV1beta1")
	ret0, _ := ret[0].(v1beta110.SchedulingV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) SchedulingV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SchedulingV1beta1")
}

func (_m *MockKubevirtClient) Scheduling() v1beta110.SchedulingV1beta1Interface {
	ret := _m.ctrl.Call(_m, "Scheduling")
	ret0, _ := ret[0].(v1beta110.SchedulingV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Scheduling() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Scheduling")
}

func (_m *MockKubevirtClient) SettingsV1alpha1() v1alpha13.SettingsV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "SettingsV1alpha1")
	ret0, _ := ret[0].(v1alpha13.SettingsV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) SettingsV1alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SettingsV1alpha1")
}

func (_m *MockKubevirtClient) Settings() v1alpha13.SettingsV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "Settings")
	ret0, _ := ret[0].(v1alpha13.SettingsV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Settings() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Settings")
}

func (_m *MockKubevirtClient) StorageV1beta1() v1beta111.StorageV1beta1Interface {
	ret := _m.ctrl.Call(_m, "StorageV1beta1")
	ret0, _ := ret[0].(v1beta111.StorageV1beta1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) StorageV1beta1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "StorageV1beta1")
}

func (_m *MockKubevirtClient) StorageV1() v110.StorageV1Interface {
	ret := _m.ctrl.Call(_m, "StorageV1")
	ret0, _ := ret[0].(v110.StorageV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) StorageV1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "StorageV1")
}

func (_m *MockKubevirtClient) Storage() v110.StorageV1Interface {
	ret := _m.ctrl.Call(_m, "Storage")
	ret0, _ := ret[0].(v110.StorageV1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Storage() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Storage")
}

func (_m *MockKubevirtClient) StorageV1alpha1() v1alpha14.StorageV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "StorageV1alpha1")
	ret0, _ := ret[0].(v1alpha14.StorageV1alpha1Interface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) StorageV1alpha1() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "StorageV1alpha1")
}

func (_m *MockKubevirtClient) Config() *rest.Config {
	ret := _m.ctrl.Call(_m, "Config")
	ret0, _ := ret[0].(*rest.Config)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) Config() *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Config")
}

// Mock of StreamInterface interface
type MockStreamInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockStreamInterfaceRecorder
}

// Recorder for MockStreamInterface (not exported)
type _MockStreamInterfaceRecorder struct {
	mock *MockStreamInterface
}

func NewMockStreamInterface(ctrl *gomock.Controller) *MockStreamInterface {
	mock := &MockStreamInterface{ctrl: ctrl}
	mock.recorder = &_MockStreamInterfaceRecorder{mock}
	return mock
}

func (_m *MockStreamInterface) EXPECT() *_MockStreamInterfaceRecorder {
	return _m.recorder
}

func (_m *MockStreamInterface) Stream(options StreamOptions) error {
	ret := _m.ctrl.Call(_m, "Stream", options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockStreamInterfaceRecorder) Stream(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Stream", arg0)
}

// Mock of VirtualMachineInstanceInterface interface
type MockVirtualMachineInstanceInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockVirtualMachineInstanceInterfaceRecorder
}

// Recorder for MockVirtualMachineInstanceInterface (not exported)
type _MockVirtualMachineInstanceInterfaceRecorder struct {
	mock *MockVirtualMachineInstanceInterface
}

func NewMockVirtualMachineInstanceInterface(ctrl *gomock.Controller) *MockVirtualMachineInstanceInterface {
	mock := &MockVirtualMachineInstanceInterface{ctrl: ctrl}
	mock.recorder = &_MockVirtualMachineInstanceInterfaceRecorder{mock}
	return mock
}

func (_m *MockVirtualMachineInstanceInterface) EXPECT() *_MockVirtualMachineInstanceInterfaceRecorder {
	return _m.recorder
}

func (_m *MockVirtualMachineInstanceInterface) Get(name string, options *v11.GetOptions) (*v111.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "Get", name, options)
	ret0, _ := ret[0].(*v111.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1)
}

func (_m *MockVirtualMachineInstanceInterface) List(opts *v11.ListOptions) (*v111.VirtualMachineInstanceList, error) {
	ret := _m.ctrl.Call(_m, "List", opts)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockVirtualMachineInstanceInterface) Create(instance *v111.VirtualMachineInstance) (*v111.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "Create", instance)
	ret0, _ := ret[0].(*v111.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Create(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0)
}

func (_m *MockVirtualMachineInstanceInterface) Update(_param0 *v111.VirtualMachineInstance) (*v111.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "Update", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Update(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0)
}

func (_m *MockVirtualMachineInstanceInterface) Delete(name string, options *v11.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1)
}

func (_m *MockVirtualMachineInstanceInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*v111.VirtualMachineInstance, error) {
	_s := []interface{}{name, pt, data}
	for _, _x := range subresources {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "Patch", _s...)
	ret0, _ := ret[0].(*v111.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
}

func (_m *MockVirtualMachineInstanceInterface) SerialConsole(name string, timeout time.Duration) (StreamInterface, error) {
	ret := _m.ctrl.Call(_m, "SerialConsole", name, timeout)
	ret0, _ := ret[0].(StreamInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) SerialConsole(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SerialConsole", arg0, arg1)
}

func (_m *MockVirtualMachineInstanceInterface) VNC(name string) (StreamInterface, error) {
	ret := _m.ctrl.Call(_m, "VNC", name)
	ret0, _ := ret[0].(StreamInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceInterfaceRecorder) VNC(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "VNC", arg0)
}

// Mock of ReplicaSetInterface interface
type MockReplicaSetInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockReplicaSetInterfaceRecorder
}

// Recorder for MockReplicaSetInterface (not exported)
type _MockReplicaSetInterfaceRecorder struct {
	mock *MockReplicaSetInterface
}

func NewMockReplicaSetInterface(ctrl *gomock.Controller) *MockReplicaSetInterface {
	mock := &MockReplicaSetInterface{ctrl: ctrl}
	mock.recorder = &_MockReplicaSetInterfaceRecorder{mock}
	return mock
}

func (_m *MockReplicaSetInterface) EXPECT() *_MockReplicaSetInterfaceRecorder {
	return _m.recorder
}

func (_m *MockReplicaSetInterface) Get(name string, options v11.GetOptions) (*v111.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "Get", name, options)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1)
}

func (_m *MockReplicaSetInterface) List(opts v11.ListOptions) (*v111.VirtualMachineInstanceReplicaSetList, error) {
	ret := _m.ctrl.Call(_m, "List", opts)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceReplicaSetList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockReplicaSetInterface) Create(_param0 *v111.VirtualMachineInstanceReplicaSet) (*v111.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "Create", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) Create(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0)
}

func (_m *MockReplicaSetInterface) Update(_param0 *v111.VirtualMachineInstanceReplicaSet) (*v111.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "Update", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) Update(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0)
}

func (_m *MockReplicaSetInterface) Delete(name string, options *v11.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockReplicaSetInterfaceRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1)
}

func (_m *MockReplicaSetInterface) GetScale(replicaSetName string, options v11.GetOptions) (*v10.Scale, error) {
	ret := _m.ctrl.Call(_m, "GetScale", replicaSetName, options)
	ret0, _ := ret[0].(*v10.Scale)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) GetScale(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "GetScale", arg0, arg1)
}

func (_m *MockReplicaSetInterface) UpdateScale(replicaSetName string, scale *v10.Scale) (*v10.Scale, error) {
	ret := _m.ctrl.Call(_m, "UpdateScale", replicaSetName, scale)
	ret0, _ := ret[0].(*v10.Scale)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) UpdateScale(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "UpdateScale", arg0, arg1)
}

func (_m *MockReplicaSetInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*v111.VirtualMachineInstanceReplicaSet, error) {
	_s := []interface{}{name, pt, data}
	for _, _x := range subresources {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "Patch", _s...)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockReplicaSetInterfaceRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
}

// Mock of VirtualMachineInstancePresetInterface interface
type MockVirtualMachineInstancePresetInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockVirtualMachineInstancePresetInterfaceRecorder
}

// Recorder for MockVirtualMachineInstancePresetInterface (not exported)
type _MockVirtualMachineInstancePresetInterfaceRecorder struct {
	mock *MockVirtualMachineInstancePresetInterface
}

func NewMockVirtualMachineInstancePresetInterface(ctrl *gomock.Controller) *MockVirtualMachineInstancePresetInterface {
	mock := &MockVirtualMachineInstancePresetInterface{ctrl: ctrl}
	mock.recorder = &_MockVirtualMachineInstancePresetInterfaceRecorder{mock}
	return mock
}

func (_m *MockVirtualMachineInstancePresetInterface) EXPECT() *_MockVirtualMachineInstancePresetInterfaceRecorder {
	return _m.recorder
}

func (_m *MockVirtualMachineInstancePresetInterface) Get(name string, options v11.GetOptions) (*v111.VirtualMachineInstancePreset, error) {
	ret := _m.ctrl.Call(_m, "Get", name, options)
	ret0, _ := ret[0].(*v111.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1)
}

func (_m *MockVirtualMachineInstancePresetInterface) List(opts v11.ListOptions) (*v111.VirtualMachineInstancePresetList, error) {
	ret := _m.ctrl.Call(_m, "List", opts)
	ret0, _ := ret[0].(*v111.VirtualMachineInstancePresetList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockVirtualMachineInstancePresetInterface) Create(_param0 *v111.VirtualMachineInstancePreset) (*v111.VirtualMachineInstancePreset, error) {
	ret := _m.ctrl.Call(_m, "Create", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Create(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0)
}

func (_m *MockVirtualMachineInstancePresetInterface) Update(_param0 *v111.VirtualMachineInstancePreset) (*v111.VirtualMachineInstancePreset, error) {
	ret := _m.ctrl.Call(_m, "Update", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Update(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0)
}

func (_m *MockVirtualMachineInstancePresetInterface) Delete(name string, options *v11.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1)
}

func (_m *MockVirtualMachineInstancePresetInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*v111.VirtualMachineInstancePreset, error) {
	_s := []interface{}{name, pt, data}
	for _, _x := range subresources {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "Patch", _s...)
	ret0, _ := ret[0].(*v111.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
}

// Mock of VirtualMachineInterface interface
type MockVirtualMachineInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockVirtualMachineInterfaceRecorder
}

// Recorder for MockVirtualMachineInterface (not exported)
type _MockVirtualMachineInterfaceRecorder struct {
	mock *MockVirtualMachineInterface
}

func NewMockVirtualMachineInterface(ctrl *gomock.Controller) *MockVirtualMachineInterface {
	mock := &MockVirtualMachineInterface{ctrl: ctrl}
	mock.recorder = &_MockVirtualMachineInterfaceRecorder{mock}
	return mock
}

func (_m *MockVirtualMachineInterface) EXPECT() *_MockVirtualMachineInterfaceRecorder {
	return _m.recorder
}

func (_m *MockVirtualMachineInterface) Get(name string, options *v11.GetOptions) (*v111.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "Get", name, options)
	ret0, _ := ret[0].(*v111.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1)
}

func (_m *MockVirtualMachineInterface) List(opts *v11.ListOptions) (*v111.VirtualMachineList, error) {
	ret := _m.ctrl.Call(_m, "List", opts)
	ret0, _ := ret[0].(*v111.VirtualMachineList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInterfaceRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockVirtualMachineInterface) Create(_param0 *v111.VirtualMachine) (*v111.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "Create", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Create(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0)
}

func (_m *MockVirtualMachineInterface) Update(_param0 *v111.VirtualMachine) (*v111.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "Update", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Update(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0)
}

func (_m *MockVirtualMachineInterface) Delete(name string, options *v11.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1)
}

func (_m *MockVirtualMachineInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*v111.VirtualMachine, error) {
	_s := []interface{}{name, pt, data}
	for _, _x := range subresources {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "Patch", _s...)
	ret0, _ := ret[0].(*v111.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
}

func (_m *MockVirtualMachineInterface) Restart(name string) error {
	ret := _m.ctrl.Call(_m, "Restart", name)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Restart(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Restart", arg0)
}

func (_m *MockVirtualMachineInterface) Start(name string) error {
	ret := _m.ctrl.Call(_m, "Start", name)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Start(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Start", arg0)
}

func (_m *MockVirtualMachineInterface) Stop(name string) error {
	ret := _m.ctrl.Call(_m, "Stop", name)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInterfaceRecorder) Stop(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Stop", arg0)
}

// Mock of VirtualMachineInstanceMigrationInterface interface
type MockVirtualMachineInstanceMigrationInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockVirtualMachineInstanceMigrationInterfaceRecorder
}

// Recorder for MockVirtualMachineInstanceMigrationInterface (not exported)
type _MockVirtualMachineInstanceMigrationInterfaceRecorder struct {
	mock *MockVirtualMachineInstanceMigrationInterface
}

func NewMockVirtualMachineInstanceMigrationInterface(ctrl *gomock.Controller) *MockVirtualMachineInstanceMigrationInterface {
	mock := &MockVirtualMachineInstanceMigrationInterface{ctrl: ctrl}
	mock.recorder = &_MockVirtualMachineInstanceMigrationInterfaceRecorder{mock}
	return mock
}

func (_m *MockVirtualMachineInstanceMigrationInterface) EXPECT() *_MockVirtualMachineInstanceMigrationInterfaceRecorder {
	return _m.recorder
}

func (_m *MockVirtualMachineInstanceMigrationInterface) Get(name string, options *v11.GetOptions) (*v111.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "Get", name, options)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1)
}

func (_m *MockVirtualMachineInstanceMigrationInterface) List(opts *v11.ListOptions) (*v111.VirtualMachineInstanceMigrationList, error) {
	ret := _m.ctrl.Call(_m, "List", opts)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceMigrationList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockVirtualMachineInstanceMigrationInterface) Create(_param0 *v111.VirtualMachineInstanceMigration) (*v111.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "Create", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Create(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0)
}

func (_m *MockVirtualMachineInstanceMigrationInterface) Update(_param0 *v111.VirtualMachineInstanceMigration) (*v111.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "Update", _param0)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Update(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0)
}

func (_m *MockVirtualMachineInstanceMigrationInterface) Delete(name string, options *v11.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1)
}

func (_m *MockVirtualMachineInstanceMigrationInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*v111.VirtualMachineInstanceMigration, error) {
	_s := []interface{}{name, pt, data}
	for _, _x := range subresources {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "Patch", _s...)
	ret0, _ := ret[0].(*v111.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockVirtualMachineInstanceMigrationInterfaceRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
}

// Mock of KubeVirtInterface interface
type MockKubeVirtInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockKubeVirtInterfaceRecorder
}

// Recorder for MockKubeVirtInterface (not exported)
type _MockKubeVirtInterfaceRecorder struct {
	mock *MockKubeVirtInterface
}

func NewMockKubeVirtInterface(ctrl *gomock.Controller) *MockKubeVirtInterface {
	mock := &MockKubeVirtInterface{ctrl: ctrl}
	mock.recorder = &_MockKubeVirtInterfaceRecorder{mock}
	return mock
}

func (_m *MockKubeVirtInterface) EXPECT() *_MockKubeVirtInterfaceRecorder {
	return _m.recorder
}

func (_m *MockKubeVirtInterface) Get(name string, options *v11.GetOptions) (*v111.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "Get", name, options)
	ret0, _ := ret[0].(*v111.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKubeVirtInterfaceRecorder) Get(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Get", arg0, arg1)
}

func (_m *MockKubeVirtInterface) List(opts *v11.ListOptions) (*v111.KubeVirtList, error) {
	ret := _m.ctrl.Call(_m, "List", opts)
	ret0, _ := ret[0].(*v111.KubeVirtList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKubeVirtInterfaceRecorder) List(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "List", arg0)
}

func (_m *MockKubeVirtInterface) Create(instance *v111.KubeVirt) (*v111.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "Create", instance)
	ret0, _ := ret[0].(*v111.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKubeVirtInterfaceRecorder) Create(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Create", arg0)
}

func (_m *MockKubeVirtInterface) Update(_param0 *v111.KubeVirt) (*v111.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "Update", _param0)
	ret0, _ := ret[0].(*v111.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKubeVirtInterfaceRecorder) Update(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Update", arg0)
}

func (_m *MockKubeVirtInterface) Delete(name string, options *v11.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

func (_mr *_MockKubeVirtInterfaceRecorder) Delete(arg0, arg1 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Delete", arg0, arg1)
}

func (_m *MockKubeVirtInterface) Patch(name string, pt types.PatchType, data []byte, subresources ...string) (*v111.KubeVirt, error) {
	_s := []interface{}{name, pt, data}
	for _, _x := range subresources {
		_s = append(_s, _x)
	}
	ret := _m.ctrl.Call(_m, "Patch", _s...)
	ret0, _ := ret[0].(*v111.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKubeVirtInterfaceRecorder) Patch(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return _mr.mock.ctrl.RecordCall(_mr.mock, "Patch", _s...)
}
