// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/aws/eks-anywhere/pkg/workflows/interfaces (interfaces: Bootstrapper,ClusterManager,GitOpsManager,Validator,CAPIManager,EksdInstaller,EksdUpgrader,PackageManager,ClusterUpgrader,ClusterCreator,ClientFactory,EksaInstaller,ClusterDeleter,ClusterMover,AwsIamAuth)

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

import (
	context "context"
	reflect "reflect"

	bootstrapper "github.com/aws/eks-anywhere/pkg/bootstrapper"
	kubernetes "github.com/aws/eks-anywhere/pkg/clients/kubernetes"
	cluster "github.com/aws/eks-anywhere/pkg/cluster"
	constants "github.com/aws/eks-anywhere/pkg/constants"
	providers "github.com/aws/eks-anywhere/pkg/providers"
	types "github.com/aws/eks-anywhere/pkg/types"
	validations "github.com/aws/eks-anywhere/pkg/validations"
	logr "github.com/go-logr/logr"
	gomock "github.com/golang/mock/gomock"
)

// MockBootstrapper is a mock of Bootstrapper interface.
type MockBootstrapper struct {
	ctrl     *gomock.Controller
	recorder *MockBootstrapperMockRecorder
}

// MockBootstrapperMockRecorder is the mock recorder for MockBootstrapper.
type MockBootstrapperMockRecorder struct {
	mock *MockBootstrapper
}

// NewMockBootstrapper creates a new mock instance.
func NewMockBootstrapper(ctrl *gomock.Controller) *MockBootstrapper {
	mock := &MockBootstrapper{ctrl: ctrl}
	mock.recorder = &MockBootstrapperMockRecorder{mock}
	return mock
}

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

// CreateBootstrapCluster mocks base method.
func (m *MockBootstrapper) CreateBootstrapCluster(arg0 context.Context, arg1 *cluster.Spec, arg2 ...bootstrapper.BootstrapClusterOption) (*types.Cluster, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateBootstrapCluster", varargs...)
	ret0, _ := ret[0].(*types.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBootstrapCluster indicates an expected call of CreateBootstrapCluster.
func (mr *MockBootstrapperMockRecorder) CreateBootstrapCluster(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBootstrapCluster", reflect.TypeOf((*MockBootstrapper)(nil).CreateBootstrapCluster), varargs...)
}

// DeleteBootstrapCluster mocks base method.
func (m *MockBootstrapper) DeleteBootstrapCluster(arg0 context.Context, arg1 *types.Cluster, arg2 constants.Operation, arg3 bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBootstrapCluster", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBootstrapCluster indicates an expected call of DeleteBootstrapCluster.
func (mr *MockBootstrapperMockRecorder) DeleteBootstrapCluster(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBootstrapCluster", reflect.TypeOf((*MockBootstrapper)(nil).DeleteBootstrapCluster), arg0, arg1, arg2, arg3)
}

// MockClusterManager is a mock of ClusterManager interface.
type MockClusterManager struct {
	ctrl     *gomock.Controller
	recorder *MockClusterManagerMockRecorder
}

// MockClusterManagerMockRecorder is the mock recorder for MockClusterManager.
type MockClusterManagerMockRecorder struct {
	mock *MockClusterManager
}

// NewMockClusterManager creates a new mock instance.
func NewMockClusterManager(ctrl *gomock.Controller) *MockClusterManager {
	mock := &MockClusterManager{ctrl: ctrl}
	mock.recorder = &MockClusterManagerMockRecorder{mock}
	return mock
}

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

// AllowDeleteWhilePaused mocks base method.
func (m *MockClusterManager) AllowDeleteWhilePaused(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllowDeleteWhilePaused", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// AllowDeleteWhilePaused indicates an expected call of AllowDeleteWhilePaused.
func (mr *MockClusterManagerMockRecorder) AllowDeleteWhilePaused(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllowDeleteWhilePaused", reflect.TypeOf((*MockClusterManager)(nil).AllowDeleteWhilePaused), arg0, arg1, arg2)
}

// ApplyBundles mocks base method.
func (m *MockClusterManager) ApplyBundles(arg0 context.Context, arg1 *cluster.Spec, arg2 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyBundles", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyBundles indicates an expected call of ApplyBundles.
func (mr *MockClusterManagerMockRecorder) ApplyBundles(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyBundles", reflect.TypeOf((*MockClusterManager)(nil).ApplyBundles), arg0, arg1, arg2)
}

// ApplyReleases mocks base method.
func (m *MockClusterManager) ApplyReleases(arg0 context.Context, arg1 *cluster.Spec, arg2 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyReleases", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyReleases indicates an expected call of ApplyReleases.
func (mr *MockClusterManagerMockRecorder) ApplyReleases(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyReleases", reflect.TypeOf((*MockClusterManager)(nil).ApplyReleases), arg0, arg1, arg2)
}

// BackupCAPI mocks base method.
func (m *MockClusterManager) BackupCAPI(arg0 context.Context, arg1 *types.Cluster, arg2, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackupCAPI", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// BackupCAPI indicates an expected call of BackupCAPI.
func (mr *MockClusterManagerMockRecorder) BackupCAPI(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackupCAPI", reflect.TypeOf((*MockClusterManager)(nil).BackupCAPI), arg0, arg1, arg2, arg3)
}

// BackupCAPIWaitForInfrastructure mocks base method.
func (m *MockClusterManager) BackupCAPIWaitForInfrastructure(arg0 context.Context, arg1 *types.Cluster, arg2, arg3 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BackupCAPIWaitForInfrastructure", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// BackupCAPIWaitForInfrastructure indicates an expected call of BackupCAPIWaitForInfrastructure.
func (mr *MockClusterManagerMockRecorder) BackupCAPIWaitForInfrastructure(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BackupCAPIWaitForInfrastructure", reflect.TypeOf((*MockClusterManager)(nil).BackupCAPIWaitForInfrastructure), arg0, arg1, arg2, arg3)
}

// CreateEKSANamespace mocks base method.
func (m *MockClusterManager) CreateEKSANamespace(arg0 context.Context, arg1 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateEKSANamespace", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// CreateRegistryCredSecret mocks base method.
func (m *MockClusterManager) CreateRegistryCredSecret(arg0 context.Context, arg1 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRegistryCredSecret", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GetCurrentClusterSpec mocks base method.
func (m *MockClusterManager) GetCurrentClusterSpec(arg0 context.Context, arg1 *types.Cluster, arg2 string) (*cluster.Spec, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCurrentClusterSpec", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cluster.Spec)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCurrentClusterSpec indicates an expected call of GetCurrentClusterSpec.
func (mr *MockClusterManagerMockRecorder) GetCurrentClusterSpec(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentClusterSpec", reflect.TypeOf((*MockClusterManager)(nil).GetCurrentClusterSpec), arg0, arg1, arg2)
}

// InstallCAPI mocks base method.
func (m *MockClusterManager) InstallCAPI(arg0 context.Context, arg1 *cluster.ManagementComponents, arg2 *cluster.Spec, arg3 *types.Cluster, arg4 providers.Provider) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallCAPI", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallCAPI indicates an expected call of InstallCAPI.
func (mr *MockClusterManagerMockRecorder) InstallCAPI(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallCAPI", reflect.TypeOf((*MockClusterManager)(nil).InstallCAPI), arg0, arg1, arg2, arg3, arg4)
}

// MoveCAPI mocks base method.
func (m *MockClusterManager) MoveCAPI(arg0 context.Context, arg1, arg2 *types.Cluster, arg3 string, arg4 *cluster.Spec, arg5 ...types.NodeReadyChecker) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3, arg4}
	for _, a := range arg5 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MoveCAPI", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// MoveCAPI indicates an expected call of MoveCAPI.
func (mr *MockClusterManagerMockRecorder) MoveCAPI(arg0, arg1, arg2, arg3, arg4 interface{}, arg5 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3, arg4}, arg5...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveCAPI", reflect.TypeOf((*MockClusterManager)(nil).MoveCAPI), varargs...)
}

// PauseCAPIWorkloadClusters mocks base method.
func (m *MockClusterManager) PauseCAPIWorkloadClusters(arg0 context.Context, arg1 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseCAPIWorkloadClusters", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// PauseEKSAControllerReconcile mocks base method.
func (m *MockClusterManager) PauseEKSAControllerReconcile(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.Spec, arg3 providers.Provider) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseEKSAControllerReconcile", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseEKSAControllerReconcile indicates an expected call of PauseEKSAControllerReconcile.
func (mr *MockClusterManagerMockRecorder) PauseEKSAControllerReconcile(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseEKSAControllerReconcile", reflect.TypeOf((*MockClusterManager)(nil).PauseEKSAControllerReconcile), arg0, arg1, arg2, arg3)
}

// ResumeCAPIWorkloadClusters mocks base method.
func (m *MockClusterManager) ResumeCAPIWorkloadClusters(arg0 context.Context, arg1 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeCAPIWorkloadClusters", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ResumeEKSAControllerReconcile mocks base method.
func (m *MockClusterManager) ResumeEKSAControllerReconcile(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.Spec, arg3 providers.Provider) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeEKSAControllerReconcile", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeEKSAControllerReconcile indicates an expected call of ResumeEKSAControllerReconcile.
func (mr *MockClusterManagerMockRecorder) ResumeEKSAControllerReconcile(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeEKSAControllerReconcile", reflect.TypeOf((*MockClusterManager)(nil).ResumeEKSAControllerReconcile), arg0, arg1, arg2, arg3)
}

// SaveLogsManagementCluster mocks base method.
func (m *MockClusterManager) SaveLogsManagementCluster(arg0 context.Context, arg1 *cluster.Spec, arg2 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveLogsManagementCluster", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveLogsManagementCluster indicates an expected call of SaveLogsManagementCluster.
func (mr *MockClusterManagerMockRecorder) SaveLogsManagementCluster(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveLogsManagementCluster", reflect.TypeOf((*MockClusterManager)(nil).SaveLogsManagementCluster), arg0, arg1, arg2)
}

// SaveLogsWorkloadCluster mocks base method.
func (m *MockClusterManager) SaveLogsWorkloadCluster(arg0 context.Context, arg1 providers.Provider, arg2 *cluster.Spec, arg3 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SaveLogsWorkloadCluster", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// SaveLogsWorkloadCluster indicates an expected call of SaveLogsWorkloadCluster.
func (mr *MockClusterManagerMockRecorder) SaveLogsWorkloadCluster(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SaveLogsWorkloadCluster", reflect.TypeOf((*MockClusterManager)(nil).SaveLogsWorkloadCluster), arg0, arg1, arg2, arg3)
}

// Upgrade mocks base method.
func (m *MockClusterManager) Upgrade(arg0 context.Context, arg1 *types.Cluster, arg2, arg3 *cluster.ManagementComponents, arg4 *cluster.Spec) (*types.ChangeDiff, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upgrade", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(*types.ChangeDiff)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Upgrade indicates an expected call of Upgrade.
func (mr *MockClusterManagerMockRecorder) Upgrade(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upgrade", reflect.TypeOf((*MockClusterManager)(nil).Upgrade), arg0, arg1, arg2, arg3, arg4)
}

// MockGitOpsManager is a mock of GitOpsManager interface.
type MockGitOpsManager struct {
	ctrl     *gomock.Controller
	recorder *MockGitOpsManagerMockRecorder
}

// MockGitOpsManagerMockRecorder is the mock recorder for MockGitOpsManager.
type MockGitOpsManagerMockRecorder struct {
	mock *MockGitOpsManager
}

// NewMockGitOpsManager creates a new mock instance.
func NewMockGitOpsManager(ctrl *gomock.Controller) *MockGitOpsManager {
	mock := &MockGitOpsManager{ctrl: ctrl}
	mock.recorder = &MockGitOpsManagerMockRecorder{mock}
	return mock
}

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

// CleanupGitRepo mocks base method.
func (m *MockGitOpsManager) CleanupGitRepo(arg0 context.Context, arg1 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CleanupGitRepo", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ForceReconcileGitRepo mocks base method.
func (m *MockGitOpsManager) ForceReconcileGitRepo(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceReconcileGitRepo", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// ForceReconcileGitRepo indicates an expected call of ForceReconcileGitRepo.
func (mr *MockGitOpsManagerMockRecorder) ForceReconcileGitRepo(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceReconcileGitRepo", reflect.TypeOf((*MockGitOpsManager)(nil).ForceReconcileGitRepo), arg0, arg1, arg2)
}

// Install mocks base method.
func (m *MockGitOpsManager) Install(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.ManagementComponents, arg3, arg4 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Install", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// Install indicates an expected call of Install.
func (mr *MockGitOpsManagerMockRecorder) Install(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Install", reflect.TypeOf((*MockGitOpsManager)(nil).Install), arg0, arg1, arg2, arg3, arg4)
}

// InstallGitOps mocks base method.
func (m *MockGitOpsManager) InstallGitOps(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.ManagementComponents, arg3 *cluster.Spec, arg4 providers.DatacenterConfig, arg5 []providers.MachineConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallGitOps", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallGitOps indicates an expected call of InstallGitOps.
func (mr *MockGitOpsManagerMockRecorder) InstallGitOps(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallGitOps", reflect.TypeOf((*MockGitOpsManager)(nil).InstallGitOps), arg0, arg1, arg2, arg3, arg4, arg5)
}

// PauseClusterResourcesReconcile mocks base method.
func (m *MockGitOpsManager) PauseClusterResourcesReconcile(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.Spec, arg3 providers.Provider) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PauseClusterResourcesReconcile", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// PauseClusterResourcesReconcile indicates an expected call of PauseClusterResourcesReconcile.
func (mr *MockGitOpsManagerMockRecorder) PauseClusterResourcesReconcile(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PauseClusterResourcesReconcile", reflect.TypeOf((*MockGitOpsManager)(nil).PauseClusterResourcesReconcile), arg0, arg1, arg2, arg3)
}

// ResumeClusterResourcesReconcile mocks base method.
func (m *MockGitOpsManager) ResumeClusterResourcesReconcile(arg0 context.Context, arg1 *types.Cluster, arg2 *cluster.Spec, arg3 providers.Provider) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ResumeClusterResourcesReconcile", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// ResumeClusterResourcesReconcile indicates an expected call of ResumeClusterResourcesReconcile.
func (mr *MockGitOpsManagerMockRecorder) ResumeClusterResourcesReconcile(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResumeClusterResourcesReconcile", reflect.TypeOf((*MockGitOpsManager)(nil).ResumeClusterResourcesReconcile), arg0, arg1, arg2, arg3)
}

// UpdateGitEksaSpec mocks base method.
func (m *MockGitOpsManager) UpdateGitEksaSpec(arg0 context.Context, arg1 *cluster.Spec, arg2 providers.DatacenterConfig, arg3 []providers.MachineConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGitEksaSpec", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateGitEksaSpec indicates an expected call of UpdateGitEksaSpec.
func (mr *MockGitOpsManagerMockRecorder) UpdateGitEksaSpec(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGitEksaSpec", reflect.TypeOf((*MockGitOpsManager)(nil).UpdateGitEksaSpec), arg0, arg1, arg2, arg3)
}

// Upgrade mocks base method.
func (m *MockGitOpsManager) Upgrade(arg0 context.Context, arg1 *types.Cluster, arg2, arg3 *cluster.ManagementComponents, arg4, arg5 *cluster.Spec) (*types.ChangeDiff, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upgrade", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*types.ChangeDiff)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Upgrade indicates an expected call of Upgrade.
func (mr *MockGitOpsManagerMockRecorder) Upgrade(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upgrade", reflect.TypeOf((*MockGitOpsManager)(nil).Upgrade), arg0, arg1, arg2, arg3, arg4, arg5)
}

// Validations mocks base method.
func (m *MockGitOpsManager) Validations(arg0 context.Context, arg1 *cluster.Spec) []validations.Validation {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Validations", arg0, arg1)
	ret0, _ := ret[0].([]validations.Validation)
	return ret0
}

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

// MockValidator is a mock of Validator interface.
type MockValidator struct {
	ctrl     *gomock.Controller
	recorder *MockValidatorMockRecorder
}

// MockValidatorMockRecorder is the mock recorder for MockValidator.
type MockValidatorMockRecorder struct {
	mock *MockValidator
}

// NewMockValidator creates a new mock instance.
func NewMockValidator(ctrl *gomock.Controller) *MockValidator {
	mock := &MockValidator{ctrl: ctrl}
	mock.recorder = &MockValidatorMockRecorder{mock}
	return mock
}

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

// PreflightValidations mocks base method.
func (m *MockValidator) PreflightValidations(arg0 context.Context) []validations.Validation {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreflightValidations", arg0)
	ret0, _ := ret[0].([]validations.Validation)
	return ret0
}

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

// MockCAPIManager is a mock of CAPIManager interface.
type MockCAPIManager struct {
	ctrl     *gomock.Controller
	recorder *MockCAPIManagerMockRecorder
}

// MockCAPIManagerMockRecorder is the mock recorder for MockCAPIManager.
type MockCAPIManagerMockRecorder struct {
	mock *MockCAPIManager
}

// NewMockCAPIManager creates a new mock instance.
func NewMockCAPIManager(ctrl *gomock.Controller) *MockCAPIManager {
	mock := &MockCAPIManager{ctrl: ctrl}
	mock.recorder = &MockCAPIManagerMockRecorder{mock}
	return mock
}

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

// EnsureEtcdProvidersInstallation mocks base method.
func (m *MockCAPIManager) EnsureEtcdProvidersInstallation(arg0 context.Context, arg1 *types.Cluster, arg2 providers.Provider, arg3 *cluster.ManagementComponents, arg4 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureEtcdProvidersInstallation", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnsureEtcdProvidersInstallation indicates an expected call of EnsureEtcdProvidersInstallation.
func (mr *MockCAPIManagerMockRecorder) EnsureEtcdProvidersInstallation(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureEtcdProvidersInstallation", reflect.TypeOf((*MockCAPIManager)(nil).EnsureEtcdProvidersInstallation), arg0, arg1, arg2, arg3, arg4)
}

// Upgrade mocks base method.
func (m *MockCAPIManager) Upgrade(arg0 context.Context, arg1 *types.Cluster, arg2 providers.Provider, arg3, arg4 *cluster.ManagementComponents, arg5 *cluster.Spec) (*types.ChangeDiff, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upgrade", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*types.ChangeDiff)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Upgrade indicates an expected call of Upgrade.
func (mr *MockCAPIManagerMockRecorder) Upgrade(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upgrade", reflect.TypeOf((*MockCAPIManager)(nil).Upgrade), arg0, arg1, arg2, arg3, arg4, arg5)
}

// MockEksdInstaller is a mock of EksdInstaller interface.
type MockEksdInstaller struct {
	ctrl     *gomock.Controller
	recorder *MockEksdInstallerMockRecorder
}

// MockEksdInstallerMockRecorder is the mock recorder for MockEksdInstaller.
type MockEksdInstallerMockRecorder struct {
	mock *MockEksdInstaller
}

// NewMockEksdInstaller creates a new mock instance.
func NewMockEksdInstaller(ctrl *gomock.Controller) *MockEksdInstaller {
	mock := &MockEksdInstaller{ctrl: ctrl}
	mock.recorder = &MockEksdInstallerMockRecorder{mock}
	return mock
}

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

// InstallEksdCRDs mocks base method.
func (m *MockEksdInstaller) InstallEksdCRDs(arg0 context.Context, arg1 *cluster.Spec, arg2 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallEksdCRDs", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallEksdCRDs indicates an expected call of InstallEksdCRDs.
func (mr *MockEksdInstallerMockRecorder) InstallEksdCRDs(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallEksdCRDs", reflect.TypeOf((*MockEksdInstaller)(nil).InstallEksdCRDs), arg0, arg1, arg2)
}

// InstallEksdManifest mocks base method.
func (m *MockEksdInstaller) InstallEksdManifest(arg0 context.Context, arg1 *cluster.Spec, arg2 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstallEksdManifest", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// InstallEksdManifest indicates an expected call of InstallEksdManifest.
func (mr *MockEksdInstallerMockRecorder) InstallEksdManifest(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstallEksdManifest", reflect.TypeOf((*MockEksdInstaller)(nil).InstallEksdManifest), arg0, arg1, arg2)
}

// MockEksdUpgrader is a mock of EksdUpgrader interface.
type MockEksdUpgrader struct {
	ctrl     *gomock.Controller
	recorder *MockEksdUpgraderMockRecorder
}

// MockEksdUpgraderMockRecorder is the mock recorder for MockEksdUpgrader.
type MockEksdUpgraderMockRecorder struct {
	mock *MockEksdUpgrader
}

// NewMockEksdUpgrader creates a new mock instance.
func NewMockEksdUpgrader(ctrl *gomock.Controller) *MockEksdUpgrader {
	mock := &MockEksdUpgrader{ctrl: ctrl}
	mock.recorder = &MockEksdUpgraderMockRecorder{mock}
	return mock
}

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

// Upgrade mocks base method.
func (m *MockEksdUpgrader) Upgrade(arg0 context.Context, arg1 *types.Cluster, arg2, arg3 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Upgrade", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Upgrade indicates an expected call of Upgrade.
func (mr *MockEksdUpgraderMockRecorder) Upgrade(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upgrade", reflect.TypeOf((*MockEksdUpgrader)(nil).Upgrade), arg0, arg1, arg2, arg3)
}

// MockPackageManager is a mock of PackageManager interface.
type MockPackageManager struct {
	ctrl     *gomock.Controller
	recorder *MockPackageManagerMockRecorder
}

// MockPackageManagerMockRecorder is the mock recorder for MockPackageManager.
type MockPackageManagerMockRecorder struct {
	mock *MockPackageManager
}

// NewMockPackageManager creates a new mock instance.
func NewMockPackageManager(ctrl *gomock.Controller) *MockPackageManager {
	mock := &MockPackageManager{ctrl: ctrl}
	mock.recorder = &MockPackageManagerMockRecorder{mock}
	return mock
}

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

// InstallCuratedPackages mocks base method.
func (m *MockPackageManager) InstallCuratedPackages(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "InstallCuratedPackages", arg0)
}

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

// UpgradeCuratedPackages mocks base method.
func (m *MockPackageManager) UpgradeCuratedPackages(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpgradeCuratedPackages", arg0)
}

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

// MockClusterUpgrader is a mock of ClusterUpgrader interface.
type MockClusterUpgrader struct {
	ctrl     *gomock.Controller
	recorder *MockClusterUpgraderMockRecorder
}

// MockClusterUpgraderMockRecorder is the mock recorder for MockClusterUpgrader.
type MockClusterUpgraderMockRecorder struct {
	mock *MockClusterUpgrader
}

// NewMockClusterUpgrader creates a new mock instance.
func NewMockClusterUpgrader(ctrl *gomock.Controller) *MockClusterUpgrader {
	mock := &MockClusterUpgrader{ctrl: ctrl}
	mock.recorder = &MockClusterUpgraderMockRecorder{mock}
	return mock
}

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

// Run mocks base method.
func (m *MockClusterUpgrader) Run(arg0 context.Context, arg1 *cluster.Spec, arg2 types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockClusterUpgraderMockRecorder) Run(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockClusterUpgrader)(nil).Run), arg0, arg1, arg2)
}

// MockClusterCreator is a mock of ClusterCreator interface.
type MockClusterCreator struct {
	ctrl     *gomock.Controller
	recorder *MockClusterCreatorMockRecorder
}

// MockClusterCreatorMockRecorder is the mock recorder for MockClusterCreator.
type MockClusterCreatorMockRecorder struct {
	mock *MockClusterCreator
}

// NewMockClusterCreator creates a new mock instance.
func NewMockClusterCreator(ctrl *gomock.Controller) *MockClusterCreator {
	mock := &MockClusterCreator{ctrl: ctrl}
	mock.recorder = &MockClusterCreatorMockRecorder{mock}
	return mock
}

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

// CreateSync mocks base method.
func (m *MockClusterCreator) CreateSync(arg0 context.Context, arg1 *cluster.Spec, arg2 *types.Cluster) (*types.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSync", arg0, arg1, arg2)
	ret0, _ := ret[0].(*types.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSync indicates an expected call of CreateSync.
func (mr *MockClusterCreatorMockRecorder) CreateSync(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSync", reflect.TypeOf((*MockClusterCreator)(nil).CreateSync), arg0, arg1, arg2)
}

// Run mocks base method.
func (m *MockClusterCreator) Run(arg0 context.Context, arg1 *cluster.Spec, arg2 types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockClusterCreatorMockRecorder) Run(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockClusterCreator)(nil).Run), arg0, arg1, arg2)
}

// MockClientFactory is a mock of ClientFactory interface.
type MockClientFactory struct {
	ctrl     *gomock.Controller
	recorder *MockClientFactoryMockRecorder
}

// MockClientFactoryMockRecorder is the mock recorder for MockClientFactory.
type MockClientFactoryMockRecorder struct {
	mock *MockClientFactory
}

// NewMockClientFactory creates a new mock instance.
func NewMockClientFactory(ctrl *gomock.Controller) *MockClientFactory {
	mock := &MockClientFactory{ctrl: ctrl}
	mock.recorder = &MockClientFactoryMockRecorder{mock}
	return mock
}

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

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

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

// MockEksaInstaller is a mock of EksaInstaller interface.
type MockEksaInstaller struct {
	ctrl     *gomock.Controller
	recorder *MockEksaInstallerMockRecorder
}

// MockEksaInstallerMockRecorder is the mock recorder for MockEksaInstaller.
type MockEksaInstallerMockRecorder struct {
	mock *MockEksaInstaller
}

// NewMockEksaInstaller creates a new mock instance.
func NewMockEksaInstaller(ctrl *gomock.Controller) *MockEksaInstaller {
	mock := &MockEksaInstaller{ctrl: ctrl}
	mock.recorder = &MockEksaInstallerMockRecorder{mock}
	return mock
}

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

// Install mocks base method.
func (m *MockEksaInstaller) Install(arg0 context.Context, arg1 logr.Logger, arg2 *types.Cluster, arg3 *cluster.ManagementComponents, arg4 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Install", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(error)
	return ret0
}

// Install indicates an expected call of Install.
func (mr *MockEksaInstallerMockRecorder) Install(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Install", reflect.TypeOf((*MockEksaInstaller)(nil).Install), arg0, arg1, arg2, arg3, arg4)
}

// MockClusterDeleter is a mock of ClusterDeleter interface.
type MockClusterDeleter struct {
	ctrl     *gomock.Controller
	recorder *MockClusterDeleterMockRecorder
}

// MockClusterDeleterMockRecorder is the mock recorder for MockClusterDeleter.
type MockClusterDeleterMockRecorder struct {
	mock *MockClusterDeleter
}

// NewMockClusterDeleter creates a new mock instance.
func NewMockClusterDeleter(ctrl *gomock.Controller) *MockClusterDeleter {
	mock := &MockClusterDeleter{ctrl: ctrl}
	mock.recorder = &MockClusterDeleterMockRecorder{mock}
	return mock
}

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

// Run mocks base method.
func (m *MockClusterDeleter) Run(arg0 context.Context, arg1 *cluster.Spec, arg2 types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockClusterDeleterMockRecorder) Run(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockClusterDeleter)(nil).Run), arg0, arg1, arg2)
}

// MockClusterMover is a mock of ClusterMover interface.
type MockClusterMover struct {
	ctrl     *gomock.Controller
	recorder *MockClusterMoverMockRecorder
}

// MockClusterMoverMockRecorder is the mock recorder for MockClusterMover.
type MockClusterMoverMockRecorder struct {
	mock *MockClusterMover
}

// NewMockClusterMover creates a new mock instance.
func NewMockClusterMover(ctrl *gomock.Controller) *MockClusterMover {
	mock := &MockClusterMover{ctrl: ctrl}
	mock.recorder = &MockClusterMoverMockRecorder{mock}
	return mock
}

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

// Move mocks base method.
func (m *MockClusterMover) Move(arg0 context.Context, arg1 *cluster.Spec, arg2, arg3 kubernetes.Client) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Move", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// Move indicates an expected call of Move.
func (mr *MockClusterMoverMockRecorder) Move(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Move", reflect.TypeOf((*MockClusterMover)(nil).Move), arg0, arg1, arg2, arg3)
}

// MockAwsIamAuth is a mock of AwsIamAuth interface.
type MockAwsIamAuth struct {
	ctrl     *gomock.Controller
	recorder *MockAwsIamAuthMockRecorder
}

// MockAwsIamAuthMockRecorder is the mock recorder for MockAwsIamAuth.
type MockAwsIamAuthMockRecorder struct {
	mock *MockAwsIamAuth
}

// NewMockAwsIamAuth creates a new mock instance.
func NewMockAwsIamAuth(ctrl *gomock.Controller) *MockAwsIamAuth {
	mock := &MockAwsIamAuth{ctrl: ctrl}
	mock.recorder = &MockAwsIamAuthMockRecorder{mock}
	return mock
}

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

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

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

// GenerateManagementKubeconfig mocks base method.
func (m *MockAwsIamAuth) GenerateManagementKubeconfig(arg0 context.Context, arg1 *types.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateManagementKubeconfig", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// GenerateWorkloadKubeconfig mocks base method.
func (m *MockAwsIamAuth) GenerateWorkloadKubeconfig(arg0 context.Context, arg1, arg2 *types.Cluster, arg3 *cluster.Spec) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateWorkloadKubeconfig", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

// GenerateWorkloadKubeconfig indicates an expected call of GenerateWorkloadKubeconfig.
func (mr *MockAwsIamAuthMockRecorder) GenerateWorkloadKubeconfig(arg0, arg1, arg2, arg3 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateWorkloadKubeconfig", reflect.TypeOf((*MockAwsIamAuth)(nil).GenerateWorkloadKubeconfig), arg0, arg1, arg2, arg3)
}
