// Code generated by MockGen. DO NOT EDIT.
// Source: controllers/cluster_controller.go

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

import (
	context "context"
	reflect "reflect"

	v1alpha1 "github.com/aws/eks-anywhere/pkg/api/v1alpha1"
	cluster "github.com/aws/eks-anywhere/pkg/cluster"
	controller "github.com/aws/eks-anywhere/pkg/controller"
	clusters "github.com/aws/eks-anywhere/pkg/controller/clusters"
	curatedpackages "github.com/aws/eks-anywhere/pkg/curatedpackages"
	vsphere "github.com/aws/eks-anywhere/pkg/providers/vsphere"
	registrymirror "github.com/aws/eks-anywhere/pkg/registrymirror"
	v1alpha10 "github.com/aws/eks-anywhere/release/api/v1alpha1"
	logr "github.com/go-logr/logr"
	gomock "github.com/golang/mock/gomock"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockPackagesClient is a mock of PackagesClient interface.
type MockPackagesClient struct {
	ctrl     *gomock.Controller
	recorder *MockPackagesClientMockRecorder
}

// MockPackagesClientMockRecorder is the mock recorder for MockPackagesClient.
type MockPackagesClientMockRecorder struct {
	mock *MockPackagesClient
}

// NewMockPackagesClient creates a new mock instance.
func NewMockPackagesClient(ctrl *gomock.Controller) *MockPackagesClient {
	mock := &MockPackagesClient{ctrl: ctrl}
	mock.recorder = &MockPackagesClientMockRecorder{mock}
	return mock
}

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

// EnableFullLifecycle mocks base method.
func (m *MockPackagesClient) EnableFullLifecycle(ctx context.Context, log logr.Logger, clusterName, kubeConfig string, chart *v1alpha10.Image, registry *registrymirror.RegistryMirror, options ...curatedpackages.PackageControllerClientOpt) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, log, clusterName, kubeConfig, chart, registry}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EnableFullLifecycle", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnableFullLifecycle indicates an expected call of EnableFullLifecycle.
func (mr *MockPackagesClientMockRecorder) EnableFullLifecycle(ctx, log, clusterName, kubeConfig, chart, registry interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, log, clusterName, kubeConfig, chart, registry}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableFullLifecycle", reflect.TypeOf((*MockPackagesClient)(nil).EnableFullLifecycle), varargs...)
}

// Reconcile mocks base method.
func (m *MockPackagesClient) Reconcile(arg0 context.Context, arg1 logr.Logger, arg2 client.Client, arg3 *v1alpha1.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reconcile", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ReconcileDelete mocks base method.
func (m *MockPackagesClient) ReconcileDelete(arg0 context.Context, arg1 logr.Logger, arg2 curatedpackages.KubeDeleter, arg3 *v1alpha1.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileDelete", arg0, arg1, arg2, arg3)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockProviderClusterReconcilerRegistry is a mock of ProviderClusterReconcilerRegistry interface.
type MockProviderClusterReconcilerRegistry struct {
	ctrl     *gomock.Controller
	recorder *MockProviderClusterReconcilerRegistryMockRecorder
}

// MockProviderClusterReconcilerRegistryMockRecorder is the mock recorder for MockProviderClusterReconcilerRegistry.
type MockProviderClusterReconcilerRegistryMockRecorder struct {
	mock *MockProviderClusterReconcilerRegistry
}

// NewMockProviderClusterReconcilerRegistry creates a new mock instance.
func NewMockProviderClusterReconcilerRegistry(ctrl *gomock.Controller) *MockProviderClusterReconcilerRegistry {
	mock := &MockProviderClusterReconcilerRegistry{ctrl: ctrl}
	mock.recorder = &MockProviderClusterReconcilerRegistryMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockProviderClusterReconcilerRegistry) Get(datacenterKind string) clusters.ProviderClusterReconciler {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", datacenterKind)
	ret0, _ := ret[0].(clusters.ProviderClusterReconciler)
	return ret0
}

// Get indicates an expected call of Get.
func (mr *MockProviderClusterReconcilerRegistryMockRecorder) Get(datacenterKind interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockProviderClusterReconcilerRegistry)(nil).Get), datacenterKind)
}

// MockAWSIamConfigReconciler is a mock of AWSIamConfigReconciler interface.
type MockAWSIamConfigReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockAWSIamConfigReconcilerMockRecorder
}

// MockAWSIamConfigReconcilerMockRecorder is the mock recorder for MockAWSIamConfigReconciler.
type MockAWSIamConfigReconcilerMockRecorder struct {
	mock *MockAWSIamConfigReconciler
}

// NewMockAWSIamConfigReconciler creates a new mock instance.
func NewMockAWSIamConfigReconciler(ctrl *gomock.Controller) *MockAWSIamConfigReconciler {
	mock := &MockAWSIamConfigReconciler{ctrl: ctrl}
	mock.recorder = &MockAWSIamConfigReconcilerMockRecorder{mock}
	return mock
}

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

// EnsureCASecret mocks base method.
func (m *MockAWSIamConfigReconciler) EnsureCASecret(ctx context.Context, logger logr.Logger, cluster *v1alpha1.Cluster) (controller.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureCASecret", ctx, logger, cluster)
	ret0, _ := ret[0].(controller.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnsureCASecret indicates an expected call of EnsureCASecret.
func (mr *MockAWSIamConfigReconcilerMockRecorder) EnsureCASecret(ctx, logger, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureCASecret", reflect.TypeOf((*MockAWSIamConfigReconciler)(nil).EnsureCASecret), ctx, logger, cluster)
}

// Reconcile mocks base method.
func (m *MockAWSIamConfigReconciler) Reconcile(ctx context.Context, logger logr.Logger, cluster *v1alpha1.Cluster) (controller.Result, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reconcile", ctx, logger, cluster)
	ret0, _ := ret[0].(controller.Result)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Reconcile indicates an expected call of Reconcile.
func (mr *MockAWSIamConfigReconcilerMockRecorder) Reconcile(ctx, logger, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reconcile", reflect.TypeOf((*MockAWSIamConfigReconciler)(nil).Reconcile), ctx, logger, cluster)
}

// ReconcileDelete mocks base method.
func (m *MockAWSIamConfigReconciler) ReconcileDelete(ctx context.Context, logger logr.Logger, cluster *v1alpha1.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileDelete", ctx, logger, cluster)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileDelete indicates an expected call of ReconcileDelete.
func (mr *MockAWSIamConfigReconcilerMockRecorder) ReconcileDelete(ctx, logger, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileDelete", reflect.TypeOf((*MockAWSIamConfigReconciler)(nil).ReconcileDelete), ctx, logger, cluster)
}

// ReconcileWorkloadClusterDelete mocks base method.
func (m *MockAWSIamConfigReconciler) ReconcileWorkloadClusterDelete(ctx context.Context, logger logr.Logger, cluster *v1alpha1.Cluster, awsIamConfig *v1alpha1.AWSIamConfig) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileWorkloadClusterDelete", ctx, logger, cluster, awsIamConfig)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileWorkloadClusterDelete indicates an expected call of ReconcileWorkloadClusterDelete.
func (mr *MockAWSIamConfigReconcilerMockRecorder) ReconcileWorkloadClusterDelete(ctx, logger, cluster, awsIamConfig interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileWorkloadClusterDelete", reflect.TypeOf((*MockAWSIamConfigReconciler)(nil).ReconcileWorkloadClusterDelete), ctx, logger, cluster, awsIamConfig)
}

// MockMachineHealthCheckReconciler is a mock of MachineHealthCheckReconciler interface.
type MockMachineHealthCheckReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockMachineHealthCheckReconcilerMockRecorder
}

// MockMachineHealthCheckReconcilerMockRecorder is the mock recorder for MockMachineHealthCheckReconciler.
type MockMachineHealthCheckReconcilerMockRecorder struct {
	mock *MockMachineHealthCheckReconciler
}

// NewMockMachineHealthCheckReconciler creates a new mock instance.
func NewMockMachineHealthCheckReconciler(ctrl *gomock.Controller) *MockMachineHealthCheckReconciler {
	mock := &MockMachineHealthCheckReconciler{ctrl: ctrl}
	mock.recorder = &MockMachineHealthCheckReconcilerMockRecorder{mock}
	return mock
}

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

// Reconcile mocks base method.
func (m *MockMachineHealthCheckReconciler) Reconcile(ctx context.Context, logger logr.Logger, cluster *v1alpha1.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reconcile", ctx, logger, cluster)
	ret0, _ := ret[0].(error)
	return ret0
}

// Reconcile indicates an expected call of Reconcile.
func (mr *MockMachineHealthCheckReconcilerMockRecorder) Reconcile(ctx, logger, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reconcile", reflect.TypeOf((*MockMachineHealthCheckReconciler)(nil).Reconcile), ctx, logger, cluster)
}

// MockClusterValidator is a mock of ClusterValidator interface.
type MockClusterValidator struct {
	ctrl     *gomock.Controller
	recorder *MockClusterValidatorMockRecorder
}

// MockClusterValidatorMockRecorder is the mock recorder for MockClusterValidator.
type MockClusterValidatorMockRecorder struct {
	mock *MockClusterValidator
}

// NewMockClusterValidator creates a new mock instance.
func NewMockClusterValidator(ctrl *gomock.Controller) *MockClusterValidator {
	mock := &MockClusterValidator{ctrl: ctrl}
	mock.recorder = &MockClusterValidatorMockRecorder{mock}
	return mock
}

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

// ValidateManagementClusterName mocks base method.
func (m *MockClusterValidator) ValidateManagementClusterName(ctx context.Context, log logr.Logger, cluster *v1alpha1.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateManagementClusterName", ctx, log, cluster)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateManagementClusterName indicates an expected call of ValidateManagementClusterName.
func (mr *MockClusterValidatorMockRecorder) ValidateManagementClusterName(ctx, log, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateManagementClusterName", reflect.TypeOf((*MockClusterValidator)(nil).ValidateManagementClusterName), ctx, log, cluster)
}

// MockSpecBuilder is a mock of SpecBuilder interface.
type MockSpecBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockSpecBuilderMockRecorder
}

// MockSpecBuilderMockRecorder is the mock recorder for MockSpecBuilder.
type MockSpecBuilderMockRecorder struct {
	mock *MockSpecBuilder
}

// NewMockSpecBuilder creates a new mock instance.
func NewMockSpecBuilder(ctrl *gomock.Controller) *MockSpecBuilder {
	mock := &MockSpecBuilder{ctrl: ctrl}
	mock.recorder = &MockSpecBuilderMockRecorder{mock}
	return mock
}

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

// BuildSpec mocks base method.
func (m *MockSpecBuilder) BuildSpec(ctx context.Context, eksaCluster *v1alpha1.Cluster) (*cluster.Spec, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildSpec", ctx, eksaCluster)
	ret0, _ := ret[0].(*cluster.Spec)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildSpec indicates an expected call of BuildSpec.
func (mr *MockSpecBuilderMockRecorder) BuildSpec(ctx, eksaCluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildSpec", reflect.TypeOf((*MockSpecBuilder)(nil).BuildSpec), ctx, eksaCluster)
}

// MockFailureDomainSpecBuilder is a mock of FailureDomainSpecBuilder interface.
type MockFailureDomainSpecBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockFailureDomainSpecBuilderMockRecorder
}

// MockFailureDomainSpecBuilderMockRecorder is the mock recorder for MockFailureDomainSpecBuilder.
type MockFailureDomainSpecBuilderMockRecorder struct {
	mock *MockFailureDomainSpecBuilder
}

// NewMockFailureDomainSpecBuilder creates a new mock instance.
func NewMockFailureDomainSpecBuilder(ctrl *gomock.Controller) *MockFailureDomainSpecBuilder {
	mock := &MockFailureDomainSpecBuilder{ctrl: ctrl}
	mock.recorder = &MockFailureDomainSpecBuilderMockRecorder{mock}
	return mock
}

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

// BuildFailureDomainSpec mocks base method.
func (m *MockFailureDomainSpecBuilder) BuildFailureDomainSpec(log logr.Logger, clusterSpec *cluster.Spec) (*vsphere.FailureDomains, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildFailureDomainSpec", log, clusterSpec)
	ret0, _ := ret[0].(*vsphere.FailureDomains)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildFailureDomainSpec indicates an expected call of BuildFailureDomainSpec.
func (mr *MockFailureDomainSpecBuilderMockRecorder) BuildFailureDomainSpec(log, clusterSpec interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildFailureDomainSpec", reflect.TypeOf((*MockFailureDomainSpecBuilder)(nil).BuildFailureDomainSpec), log, clusterSpec)
}

// MockObjectReconciler is a mock of ObjectReconciler interface.
type MockObjectReconciler struct {
	ctrl     *gomock.Controller
	recorder *MockObjectReconcilerMockRecorder
}

// MockObjectReconcilerMockRecorder is the mock recorder for MockObjectReconciler.
type MockObjectReconcilerMockRecorder struct {
	mock *MockObjectReconciler
}

// NewMockObjectReconciler creates a new mock instance.
func NewMockObjectReconciler(ctrl *gomock.Controller) *MockObjectReconciler {
	mock := &MockObjectReconciler{ctrl: ctrl}
	mock.recorder = &MockObjectReconcilerMockRecorder{mock}
	return mock
}

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

// ReconcileObjects mocks base method.
func (m *MockObjectReconciler) ReconcileObjects(ctx context.Context, fd *vsphere.FailureDomains) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReconcileObjects", ctx, fd)
	ret0, _ := ret[0].(error)
	return ret0
}

// ReconcileObjects indicates an expected call of ReconcileObjects.
func (mr *MockObjectReconcilerMockRecorder) ReconcileObjects(ctx, fd interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReconcileObjects", reflect.TypeOf((*MockObjectReconciler)(nil).ReconcileObjects), ctx, fd)
}

// MockFailureDomainApplier is a mock of FailureDomainApplier interface.
type MockFailureDomainApplier struct {
	ctrl     *gomock.Controller
	recorder *MockFailureDomainApplierMockRecorder
}

// MockFailureDomainApplierMockRecorder is the mock recorder for MockFailureDomainApplier.
type MockFailureDomainApplierMockRecorder struct {
	mock *MockFailureDomainApplier
}

// NewMockFailureDomainApplier creates a new mock instance.
func NewMockFailureDomainApplier(ctrl *gomock.Controller) *MockFailureDomainApplier {
	mock := &MockFailureDomainApplier{ctrl: ctrl}
	mock.recorder = &MockFailureDomainApplierMockRecorder{mock}
	return mock
}

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

// ApplyFailureDomains mocks base method.
func (m *MockFailureDomainApplier) ApplyFailureDomains(ctx context.Context, log logr.Logger, cluster *v1alpha1.Cluster) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyFailureDomains", ctx, log, cluster)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyFailureDomains indicates an expected call of ApplyFailureDomains.
func (mr *MockFailureDomainApplierMockRecorder) ApplyFailureDomains(ctx, log, cluster interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyFailureDomains", reflect.TypeOf((*MockFailureDomainApplier)(nil).ApplyFailureDomains), ctx, log, cluster)
}
