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

package kubecli

import (
	context "context"
	time "time"

	gomock "github.com/golang/mock/gomock"
	v1 "github.com/openshift/client-go/route/clientset/versioned/typed/route/v1"
	v10 "github.com/openshift/client-go/security/clientset/versioned/typed/security/v1"
	v11 "k8s.io/api/autoscaling/v1"
	clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
	v12 "k8s.io/apimachinery/pkg/apis/meta/v1"
	types "k8s.io/apimachinery/pkg/types"
	watch "k8s.io/apimachinery/pkg/watch"
	discovery "k8s.io/client-go/discovery"
	dynamic "k8s.io/client-go/dynamic"
	v13 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1"
	v1alpha1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1alpha1"
	v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1"
	v1alpha10 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1"
	v14 "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"
	v15 "k8s.io/client-go/kubernetes/typed/authentication/v1"
	v1alpha11 "k8s.io/client-go/kubernetes/typed/authentication/v1alpha1"
	v1beta11 "k8s.io/client-go/kubernetes/typed/authentication/v1beta1"
	v16 "k8s.io/client-go/kubernetes/typed/authorization/v1"
	v1beta12 "k8s.io/client-go/kubernetes/typed/authorization/v1beta1"
	v17 "k8s.io/client-go/kubernetes/typed/autoscaling/v1"
	v2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2"
	v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1"
	v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2"
	v18 "k8s.io/client-go/kubernetes/typed/batch/v1"
	v1beta13 "k8s.io/client-go/kubernetes/typed/batch/v1beta1"
	v19 "k8s.io/client-go/kubernetes/typed/certificates/v1"
	v1alpha12 "k8s.io/client-go/kubernetes/typed/certificates/v1alpha1"
	v1beta14 "k8s.io/client-go/kubernetes/typed/certificates/v1beta1"
	v110 "k8s.io/client-go/kubernetes/typed/coordination/v1"
	v1beta15 "k8s.io/client-go/kubernetes/typed/coordination/v1beta1"
	v111 "k8s.io/client-go/kubernetes/typed/core/v1"
	v112 "k8s.io/client-go/kubernetes/typed/discovery/v1"
	v1beta16 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1"
	v113 "k8s.io/client-go/kubernetes/typed/events/v1"
	v1beta17 "k8s.io/client-go/kubernetes/typed/events/v1beta1"
	v1beta18 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1"
	v114 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1"
	v1beta19 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1"
	v1beta20 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta2"
	v1beta3 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta3"
	v115 "k8s.io/client-go/kubernetes/typed/networking/v1"
	v1alpha13 "k8s.io/client-go/kubernetes/typed/networking/v1alpha1"
	v1beta110 "k8s.io/client-go/kubernetes/typed/networking/v1beta1"
	v116 "k8s.io/client-go/kubernetes/typed/node/v1"
	v1alpha14 "k8s.io/client-go/kubernetes/typed/node/v1alpha1"
	v1beta111 "k8s.io/client-go/kubernetes/typed/node/v1beta1"
	v117 "k8s.io/client-go/kubernetes/typed/policy/v1"
	v1beta112 "k8s.io/client-go/kubernetes/typed/policy/v1beta1"
	v118 "k8s.io/client-go/kubernetes/typed/rbac/v1"
	v1alpha15 "k8s.io/client-go/kubernetes/typed/rbac/v1alpha1"
	v1beta113 "k8s.io/client-go/kubernetes/typed/rbac/v1beta1"
	v1alpha2 "k8s.io/client-go/kubernetes/typed/resource/v1alpha2"
	v119 "k8s.io/client-go/kubernetes/typed/scheduling/v1"
	v1alpha16 "k8s.io/client-go/kubernetes/typed/scheduling/v1alpha1"
	v1beta114 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1"
	v120 "k8s.io/client-go/kubernetes/typed/storage/v1"
	v1alpha17 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1"
	v1beta115 "k8s.io/client-go/kubernetes/typed/storage/v1beta1"
	v1alpha18 "k8s.io/client-go/kubernetes/typed/storagemigration/v1alpha1"
	rest "k8s.io/client-go/rest"
	v121 "kubevirt.io/api/core/v1"
	versioned "kubevirt.io/client-go/generated/containerized-data-importer/clientset/versioned"
	versioned0 "kubevirt.io/client-go/generated/external-snapshotter/clientset/versioned"
	versioned1 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned"
	v1alpha19 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/clone/v1alpha1"
	v122 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/core/v1"
	v1beta116 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/export/v1beta1"
	v1beta117 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/instancetype/v1beta1"
	v1alpha110 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/migrations/v1alpha1"
	v1alpha111 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/pool/v1alpha1"
	v1beta118 "kubevirt.io/client-go/generated/kubevirt/clientset/versioned/typed/snapshot/v1beta1"
	versioned2 "kubevirt.io/client-go/generated/network-attachment-definition-client/clientset/versioned"
	versioned3 "kubevirt.io/client-go/generated/prometheus-operator/clientset/versioned"
	version "kubevirt.io/client-go/version"
)

// 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) VirtualMachinePool(namespace string) v1alpha111.VirtualMachinePoolInterface {
	ret := _m.ctrl.Call(_m, "VirtualMachinePool", namespace)
	ret0, _ := ret[0].(v1alpha111.VirtualMachinePoolInterface)
	return ret0
}

func (_mr *_MockKubevirtClientRecorder) VirtualMachinePool(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "VirtualMachinePool", 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) VirtualMachineSnapshot(namespace string) v1beta118.VirtualMachineSnapshotInterface {
	ret := _m.ctrl.Call(_m, "VirtualMachineSnapshot", namespace)
	ret0, _ := ret[0].(v1beta118.VirtualMachineSnapshotInterface)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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) GeneratedKubeVirtClient() versioned1.Interface {
	ret := _m.ctrl.Call(_m, "GeneratedKubeVirtClient")
	ret0, _ := ret[0].(versioned1.Interface)
	return ret0
}

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

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

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

func (_m *MockKubevirtClient) NetworkClient() versioned2.Interface {
	ret := _m.ctrl.Call(_m, "NetworkClient")
	ret0, _ := ret[0].(versioned2.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() v10.SecurityV1Interface {
	ret := _m.ctrl.Call(_m, "SecClient")
	ret0, _ := ret[0].(v10.SecurityV1Interface)
	return ret0
}

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

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

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

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) PrometheusClient() versioned3.Interface {
	ret := _m.ctrl.Call(_m, "PrometheusClient")
	ret0, _ := ret[0].(versioned3.Interface)
	return ret0
}

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

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

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

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

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

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

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

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) AdmissionregistrationV1() v13.AdmissionregistrationV1Interface {
	ret := _m.ctrl.Call(_m, "AdmissionregistrationV1")
	ret0, _ := ret[0].(v13.AdmissionregistrationV1Interface)
	return ret0
}

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

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) InternalV1alpha1() v1alpha10.InternalV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "InternalV1alpha1")
	ret0, _ := ret[0].(v1alpha10.InternalV1alpha1Interface)
	return ret0
}

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

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

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

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) AuthenticationV1() v15.AuthenticationV1Interface {
	ret := _m.ctrl.Call(_m, "AuthenticationV1")
	ret0, _ := ret[0].(v15.AuthenticationV1Interface)
	return ret0
}

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

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

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

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() v16.AuthorizationV1Interface {
	ret := _m.ctrl.Call(_m, "AuthorizationV1")
	ret0, _ := ret[0].(v16.AuthorizationV1Interface)
	return ret0
}

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

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() v17.AutoscalingV1Interface {
	ret := _m.ctrl.Call(_m, "AutoscalingV1")
	ret0, _ := ret[0].(v17.AutoscalingV1Interface)
	return ret0
}

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

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

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

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() v18.BatchV1Interface {
	ret := _m.ctrl.Call(_m, "BatchV1")
	ret0, _ := ret[0].(v18.BatchV1Interface)
	return ret0
}

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

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) CertificatesV1() v19.CertificatesV1Interface {
	ret := _m.ctrl.Call(_m, "CertificatesV1")
	ret0, _ := ret[0].(v19.CertificatesV1Interface)
	return ret0
}

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

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) CertificatesV1alpha1() v1alpha12.CertificatesV1alpha1Interface {
	ret := _m.ctrl.Call(_m, "CertificatesV1alpha1")
	ret0, _ := ret[0].(v1alpha12.CertificatesV1alpha1Interface)
	return ret0
}

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

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) CoordinationV1() v110.CoordinationV1Interface {
	ret := _m.ctrl.Call(_m, "CoordinationV1")
	ret0, _ := ret[0].(v110.CoordinationV1Interface)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (_m *MockKubevirtClient) SetRestTimeout(timeout time.Duration) (KubevirtClient, error) {
	ret := _m.ctrl.Call(_m, "SetRestTimeout", timeout)
	ret0, _ := ret[0].(KubevirtClient)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (_mr *_MockKubevirtClientRecorder) SetRestTimeout(arg0 interface{}) *gomock.Call {
	return _mr.mock.ctrl.RecordCall(_mr.mock, "SetRestTimeout", 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) Create(ctx context.Context, virtualMachineInstance *v121.VirtualMachineInstance, opts v12.CreateOptions) (*v121.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstance, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) Update(ctx context.Context, virtualMachineInstance *v121.VirtualMachineInstance, opts v12.UpdateOptions) (*v121.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstance, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) UpdateStatus(ctx context.Context, virtualMachineInstance *v121.VirtualMachineInstance, opts v12.UpdateOptions) (*v121.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachineInstance, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
	ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstance, error) {
	ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInstanceInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
	ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInstanceInterface) SerialConsole(name string, options *v122.SerialConsoleOptions) (v122.StreamInterface, error) {
	ret := _m.ctrl.Call(_m, "SerialConsole", name, options)
	ret0, _ := ret[0].(v122.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) USBRedir(vmiName string) (v122.StreamInterface, error) {
	ret := _m.ctrl.Call(_m, "USBRedir", vmiName)
	ret0, _ := ret[0].(v122.StreamInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) VNC(name string) (v122.StreamInterface, error) {
	ret := _m.ctrl.Call(_m, "VNC", name)
	ret0, _ := ret[0].(v122.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)
}

func (_m *MockVirtualMachineInstanceInterface) Screenshot(ctx context.Context, name string, options *v121.ScreenshotOptions) ([]byte, error) {
	ret := _m.ctrl.Call(_m, "Screenshot", ctx, name, options)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInstanceInterface) Pause(ctx context.Context, name string, pauseOptions *v121.PauseOptions) error {
	ret := _m.ctrl.Call(_m, "Pause", ctx, name, pauseOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) Unpause(ctx context.Context, name string, unpauseOptions *v121.UnpauseOptions) error {
	ret := _m.ctrl.Call(_m, "Unpause", ctx, name, unpauseOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) Freeze(ctx context.Context, name string, unfreezeTimeout time.Duration) error {
	ret := _m.ctrl.Call(_m, "Freeze", ctx, name, unfreezeTimeout)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) Unfreeze(ctx context.Context, name string) error {
	ret := _m.ctrl.Call(_m, "Unfreeze", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) SoftReboot(ctx context.Context, name string) error {
	ret := _m.ctrl.Call(_m, "SoftReboot", ctx, name)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) GuestOsInfo(ctx context.Context, name string) (v121.VirtualMachineInstanceGuestAgentInfo, error) {
	ret := _m.ctrl.Call(_m, "GuestOsInfo", ctx, name)
	ret0, _ := ret[0].(v121.VirtualMachineInstanceGuestAgentInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) UserList(ctx context.Context, name string) (v121.VirtualMachineInstanceGuestOSUserList, error) {
	ret := _m.ctrl.Call(_m, "UserList", ctx, name)
	ret0, _ := ret[0].(v121.VirtualMachineInstanceGuestOSUserList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) FilesystemList(ctx context.Context, name string) (v121.VirtualMachineInstanceFileSystemList, error) {
	ret := _m.ctrl.Call(_m, "FilesystemList", ctx, name)
	ret0, _ := ret[0].(v121.VirtualMachineInstanceFileSystemList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) AddVolume(ctx context.Context, name string, addVolumeOptions *v121.AddVolumeOptions) error {
	ret := _m.ctrl.Call(_m, "AddVolume", ctx, name, addVolumeOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) RemoveVolume(ctx context.Context, name string, removeVolumeOptions *v121.RemoveVolumeOptions) error {
	ret := _m.ctrl.Call(_m, "RemoveVolume", ctx, name, removeVolumeOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

func (_m *MockVirtualMachineInstanceInterface) SEVFetchCertChain(ctx context.Context, name string) (v121.SEVPlatformInfo, error) {
	ret := _m.ctrl.Call(_m, "SEVFetchCertChain", ctx, name)
	ret0, _ := ret[0].(v121.SEVPlatformInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) SEVQueryLaunchMeasurement(ctx context.Context, name string) (v121.SEVMeasurementInfo, error) {
	ret := _m.ctrl.Call(_m, "SEVQueryLaunchMeasurement", ctx, name)
	ret0, _ := ret[0].(v121.SEVMeasurementInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceInterface) SEVSetupSession(ctx context.Context, name string, sevSessionOptions *v121.SEVSessionOptions) error {
	ret := _m.ctrl.Call(_m, "SEVSetupSession", ctx, name, sevSessionOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceInterface) SEVInjectLaunchSecret(ctx context.Context, name string, sevSecretOptions *v121.SEVSecretOptions) error {
	ret := _m.ctrl.Call(_m, "SEVInjectLaunchSecret", ctx, name, sevSecretOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// 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) Create(ctx context.Context, virtualMachineInstanceReplicaSet *v121.VirtualMachineInstanceReplicaSet, opts v12.CreateOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstanceReplicaSet, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockReplicaSetInterface) Update(ctx context.Context, virtualMachineInstanceReplicaSet *v121.VirtualMachineInstanceReplicaSet, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstanceReplicaSet, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockReplicaSetInterface) UpdateStatus(ctx context.Context, virtualMachineInstanceReplicaSet *v121.VirtualMachineInstanceReplicaSet, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachineInstanceReplicaSet, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockReplicaSetInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockReplicaSetInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
	ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockReplicaSetInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockReplicaSetInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
	ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

func (_m *MockReplicaSetInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions) (*v121.VirtualMachineInstanceReplicaSet, error) {
	ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceReplicaSet)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// 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) Create(ctx context.Context, virtualMachineInstancePreset *v121.VirtualMachineInstancePreset, opts v12.CreateOptions) (*v121.VirtualMachineInstancePreset, error) {
	ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstancePreset, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstancePresetInterface) Update(ctx context.Context, virtualMachineInstancePreset *v121.VirtualMachineInstancePreset, opts v12.UpdateOptions) (*v121.VirtualMachineInstancePreset, error) {
	ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstancePreset, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstancePresetInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstancePresetInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
	ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstancePresetInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstancePreset, error) {
	ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstancePreset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInstancePresetInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
	ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

func (_mr *_MockVirtualMachineInstancePresetInterfaceRecorder) Patch(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
	_s := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
	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) Create(ctx context.Context, virtualMachine *v121.VirtualMachine, opts v12.CreateOptions) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachine, opts)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInterface) Update(ctx context.Context, virtualMachine *v121.VirtualMachine, opts v12.UpdateOptions) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachine, opts)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInterface) UpdateStatus(ctx context.Context, virtualMachine *v121.VirtualMachine, opts v12.UpdateOptions) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachine, opts)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
	ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
	ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInterface) GetWithExpandedSpec(ctx context.Context, name string) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "GetWithExpandedSpec", ctx, name)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, patchOptions v12.PatchOptions) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, patchOptions)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInterface) ForceRestart(ctx context.Context, name string, restartOptions *v121.RestartOptions) error {
	ret := _m.ctrl.Call(_m, "ForceRestart", ctx, name, restartOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

func (_m *MockVirtualMachineInterface) ForceStop(ctx context.Context, name string, stopOptions *v121.StopOptions) error {
	ret := _m.ctrl.Call(_m, "ForceStop", ctx, name, stopOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInterface) Migrate(ctx context.Context, name string, migrateOptions *v121.MigrateOptions) error {
	ret := _m.ctrl.Call(_m, "Migrate", ctx, name, migrateOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInterface) AddVolume(ctx context.Context, name string, addVolumeOptions *v121.AddVolumeOptions) error {
	ret := _m.ctrl.Call(_m, "AddVolume", ctx, name, addVolumeOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInterface) RemoveVolume(ctx context.Context, name string, removeVolumeOptions *v121.RemoveVolumeOptions) error {
	ret := _m.ctrl.Call(_m, "RemoveVolume", ctx, name, removeVolumeOptions)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInterface) PortForward(name string, port int, protocol string) (v122.StreamInterface, error) {
	ret := _m.ctrl.Call(_m, "PortForward", name, port, protocol)
	ret0, _ := ret[0].(v122.StreamInterface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInterface) MemoryDump(ctx context.Context, name string, memoryDumpRequest *v121.VirtualMachineMemoryDumpRequest) error {
	ret := _m.ctrl.Call(_m, "MemoryDump", ctx, name, memoryDumpRequest)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// 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) Create(ctx context.Context, virtualMachineInstanceMigration *v121.VirtualMachineInstanceMigration, opts v12.CreateOptions) (*v121.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "Create", ctx, virtualMachineInstanceMigration, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceMigrationInterface) Update(ctx context.Context, virtualMachineInstanceMigration *v121.VirtualMachineInstanceMigration, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "Update", ctx, virtualMachineInstanceMigration, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceMigrationInterface) UpdateStatus(ctx context.Context, virtualMachineInstanceMigration *v121.VirtualMachineInstanceMigration, opts v12.UpdateOptions) (*v121.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, virtualMachineInstanceMigration, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockVirtualMachineInstanceMigrationInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceMigrationInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
	ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockVirtualMachineInstanceMigrationInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInstanceMigrationInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
	ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockVirtualMachineInstanceMigrationInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, opts v12.PatchOptions) (*v121.VirtualMachineInstanceMigration, error) {
	ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, opts)
	ret0, _ := ret[0].(*v121.VirtualMachineInstanceMigration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// 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) Create(ctx context.Context, kubeVirt *v121.KubeVirt, opts v12.CreateOptions) (*v121.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "Create", ctx, kubeVirt, opts)
	ret0, _ := ret[0].(*v121.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockKubeVirtInterface) Update(ctx context.Context, kubeVirt *v121.KubeVirt, opts v12.UpdateOptions) (*v121.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "Update", ctx, kubeVirt, opts)
	ret0, _ := ret[0].(*v121.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockKubeVirtInterface) UpdateStatus(ctx context.Context, kubeVirt *v121.KubeVirt, opts v12.UpdateOptions) (*v121.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "UpdateStatus", ctx, kubeVirt, opts)
	ret0, _ := ret[0].(*v121.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

func (_m *MockKubeVirtInterface) Delete(ctx context.Context, name string, opts v12.DeleteOptions) error {
	ret := _m.ctrl.Call(_m, "Delete", ctx, name, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockKubeVirtInterface) DeleteCollection(ctx context.Context, opts v12.DeleteOptions, listOpts v12.ListOptions) error {
	ret := _m.ctrl.Call(_m, "DeleteCollection", ctx, opts, listOpts)
	ret0, _ := ret[0].(error)
	return ret0
}

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

func (_m *MockKubeVirtInterface) Get(ctx context.Context, name string, opts v12.GetOptions) (*v121.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "Get", ctx, name, opts)
	ret0, _ := ret[0].(*v121.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockKubeVirtInterface) Watch(ctx context.Context, opts v12.ListOptions) (watch.Interface, error) {
	ret := _m.ctrl.Call(_m, "Watch", ctx, opts)
	ret0, _ := ret[0].(watch.Interface)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

func (_m *MockKubeVirtInterface) PatchStatus(ctx context.Context, name string, pt types.PatchType, data []byte, patchOptions v12.PatchOptions) (*v121.KubeVirt, error) {
	ret := _m.ctrl.Call(_m, "PatchStatus", ctx, name, pt, data, patchOptions)
	ret0, _ := ret[0].(*v121.KubeVirt)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Mock of ServerVersionInterface interface
type MockServerVersionInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockServerVersionInterfaceRecorder
}

// Recorder for MockServerVersionInterface (not exported)
type _MockServerVersionInterfaceRecorder struct {
	mock *MockServerVersionInterface
}

func NewMockServerVersionInterface(ctrl *gomock.Controller) *MockServerVersionInterface {
	mock := &MockServerVersionInterface{ctrl: ctrl}
	mock.recorder = &_MockServerVersionInterfaceRecorder{mock}
	return mock
}

func (_m *MockServerVersionInterface) EXPECT() *_MockServerVersionInterfaceRecorder {
	return _m.recorder
}

func (_m *MockServerVersionInterface) Get() (*version.Info, error) {
	ret := _m.ctrl.Call(_m, "Get")
	ret0, _ := ret[0].(*version.Info)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Mock of ExpandSpecInterface interface
type MockExpandSpecInterface struct {
	ctrl     *gomock.Controller
	recorder *_MockExpandSpecInterfaceRecorder
}

// Recorder for MockExpandSpecInterface (not exported)
type _MockExpandSpecInterfaceRecorder struct {
	mock *MockExpandSpecInterface
}

func NewMockExpandSpecInterface(ctrl *gomock.Controller) *MockExpandSpecInterface {
	mock := &MockExpandSpecInterface{ctrl: ctrl}
	mock.recorder = &_MockExpandSpecInterfaceRecorder{mock}
	return mock
}

func (_m *MockExpandSpecInterface) EXPECT() *_MockExpandSpecInterfaceRecorder {
	return _m.recorder
}

func (_m *MockExpandSpecInterface) ForVirtualMachine(vm *v121.VirtualMachine) (*v121.VirtualMachine, error) {
	ret := _m.ctrl.Call(_m, "ForVirtualMachine", vm)
	ret0, _ := ret[0].(*v121.VirtualMachine)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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