package mock

import (
	context "context"
	reflect "reflect"

	v1beta1 "github.com/gardener/gardener/pkg/apis/core/v1beta1"
	v1alpha1 "github.com/gardener/gardener/pkg/apis/seedmanagement/v1alpha1"
	managedseedset "github.com/gardener/gardener/pkg/controllermanager/controller/managedseedset"
	shoot "github.com/gardener/gardener/pkg/operation/shoot"
	gomock "github.com/golang/mock/gomock"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)

type MockActuator struct {
	ctrl     *gomock.Controller
	recorder *MockActuatorMockRecorder
}

type MockActuatorMockRecorder struct {
	mock *MockActuator
}

func NewMockActuator(ctrl *gomock.Controller) *MockActuator {
	mock := &MockActuator{ctrl: ctrl}
	mock.recorder = &MockActuatorMockRecorder{mock}
	return mock
}

func (m *MockActuator) EXPECT() *MockActuatorMockRecorder {
	return m.recorder
}

func (m *MockActuator) Reconcile(arg0 context.Context, arg1 *v1alpha1.ManagedSeedSet) (*v1alpha1.ManagedSeedSetStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reconcile", arg0, arg1)
	ret0, _ := ret[0].(*v1alpha1.ManagedSeedSetStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockActuatorMockRecorder) Reconcile(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reconcile", reflect.TypeOf((*MockActuator)(nil).Reconcile), arg0, arg1)
}

type MockReplica struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaMockRecorder
}

type MockReplicaMockRecorder struct {
	mock *MockReplica
}

func NewMockReplica(ctrl *gomock.Controller) *MockReplica {
	mock := &MockReplica{ctrl: ctrl}
	mock.recorder = &MockReplicaMockRecorder{mock}
	return mock
}

func (m *MockReplica) EXPECT() *MockReplicaMockRecorder {
	return m.recorder
}

func (m *MockReplica) CreateManagedSeed(arg0 context.Context, arg1 client.Client) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateManagedSeed", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockReplicaMockRecorder) CreateManagedSeed(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateManagedSeed", reflect.TypeOf((*MockReplica)(nil).CreateManagedSeed), arg0, arg1)
}

func (m *MockReplica) CreateShoot(arg0 context.Context, arg1 client.Client, arg2 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateShoot", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockReplicaMockRecorder) CreateShoot(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateShoot", reflect.TypeOf((*MockReplica)(nil).CreateShoot), arg0, arg1, arg2)
}

func (m *MockReplica) DeleteManagedSeed(arg0 context.Context, arg1 client.Client) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteManagedSeed", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockReplicaMockRecorder) DeleteManagedSeed(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteManagedSeed", reflect.TypeOf((*MockReplica)(nil).DeleteManagedSeed), arg0, arg1)
}

func (m *MockReplica) DeleteShoot(arg0 context.Context, arg1 client.Client) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteShoot", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockReplicaMockRecorder) DeleteShoot(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteShoot", reflect.TypeOf((*MockReplica)(nil).DeleteShoot), arg0, arg1)
}

func (m *MockReplica) GetFullName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetFullName")
	ret0, _ := ret[0].(string)
	return ret0
}

func (mr *MockReplicaMockRecorder) GetFullName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFullName", reflect.TypeOf((*MockReplica)(nil).GetFullName))
}

func (m *MockReplica) GetName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetName")
	ret0, _ := ret[0].(string)
	return ret0
}

func (mr *MockReplicaMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockReplica)(nil).GetName))
}

func (m *MockReplica) GetOrdinal() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrdinal")
	ret0, _ := ret[0].(int)
	return ret0
}

func (mr *MockReplicaMockRecorder) GetOrdinal() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrdinal", reflect.TypeOf((*MockReplica)(nil).GetOrdinal))
}

func (m *MockReplica) GetShootHealthStatus() shoot.Status {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShootHealthStatus")
	ret0, _ := ret[0].(shoot.Status)
	return ret0
}

func (mr *MockReplicaMockRecorder) GetShootHealthStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShootHealthStatus", reflect.TypeOf((*MockReplica)(nil).GetShootHealthStatus))
}

func (m *MockReplica) GetStatus() managedseedset.ReplicaStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatus")
	ret0, _ := ret[0].(managedseedset.ReplicaStatus)
	return ret0
}

func (mr *MockReplicaMockRecorder) GetStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatus", reflect.TypeOf((*MockReplica)(nil).GetStatus))
}

func (m *MockReplica) IsDeletable() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDeletable")
	ret0, _ := ret[0].(bool)
	return ret0
}

func (mr *MockReplicaMockRecorder) IsDeletable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDeletable", reflect.TypeOf((*MockReplica)(nil).IsDeletable))
}

func (m *MockReplica) IsSeedReady() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSeedReady")
	ret0, _ := ret[0].(bool)
	return ret0
}

func (mr *MockReplicaMockRecorder) IsSeedReady() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSeedReady", reflect.TypeOf((*MockReplica)(nil).IsSeedReady))
}

func (m *MockReplica) RetryShoot(arg0 context.Context, arg1 client.Client) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RetryShoot", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

func (mr *MockReplicaMockRecorder) RetryShoot(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RetryShoot", reflect.TypeOf((*MockReplica)(nil).RetryShoot), arg0, arg1)
}

type MockReplicaFactory struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaFactoryMockRecorder
}

type MockReplicaFactoryMockRecorder struct {
	mock *MockReplicaFactory
}

func NewMockReplicaFactory(ctrl *gomock.Controller) *MockReplicaFactory {
	mock := &MockReplicaFactory{ctrl: ctrl}
	mock.recorder = &MockReplicaFactoryMockRecorder{mock}
	return mock
}

func (m *MockReplicaFactory) EXPECT() *MockReplicaFactoryMockRecorder {
	return m.recorder
}

func (m *MockReplicaFactory) NewReplica(arg0 *v1alpha1.ManagedSeedSet, arg1 *v1beta1.Shoot, arg2 *v1alpha1.ManagedSeed, arg3 *v1beta1.Seed, arg4 bool) managedseedset.Replica {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplica", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(managedseedset.Replica)
	return ret0
}

func (mr *MockReplicaFactoryMockRecorder) NewReplica(arg0, arg1, arg2, arg3, arg4 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReplica", reflect.TypeOf((*MockReplicaFactory)(nil).NewReplica), arg0, arg1, arg2, arg3, arg4)
}

type MockReplicaGetter struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaGetterMockRecorder
}

type MockReplicaGetterMockRecorder struct {
	mock *MockReplicaGetter
}

func NewMockReplicaGetter(ctrl *gomock.Controller) *MockReplicaGetter {
	mock := &MockReplicaGetter{ctrl: ctrl}
	mock.recorder = &MockReplicaGetterMockRecorder{mock}
	return mock
}

func (m *MockReplicaGetter) EXPECT() *MockReplicaGetterMockRecorder {
	return m.recorder
}

func (m *MockReplicaGetter) GetReplicas(arg0 context.Context, arg1 *v1alpha1.ManagedSeedSet) ([]managedseedset.Replica, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicas", arg0, arg1)
	ret0, _ := ret[0].([]managedseedset.Replica)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

func (mr *MockReplicaGetterMockRecorder) GetReplicas(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReplicas", reflect.TypeOf((*MockReplicaGetter)(nil).GetReplicas), arg0, arg1)
}
// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/gardener/gardener/pkg/controllermanager/controller/managedseedset (interfaces: Actuator,Replica,ReplicaFactory,ReplicaGetter)

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

import (
	context "context"
	reflect "reflect"

	v1beta1 "github.com/gardener/gardener/pkg/apis/core/v1beta1"
	v1alpha1 "github.com/gardener/gardener/pkg/apis/seedmanagement/v1alpha1"
	managedseedset "github.com/gardener/gardener/pkg/controllermanager/controller/managedseedset"
	shoot "github.com/gardener/gardener/pkg/operation/shoot"
	gomock "github.com/golang/mock/gomock"
	client "sigs.k8s.io/controller-runtime/pkg/client"
)

// MockActuator is a mock of Actuator interface.
type MockActuator struct {
	ctrl     *gomock.Controller
	recorder *MockActuatorMockRecorder
}

// MockActuatorMockRecorder is the mock recorder for MockActuator.
type MockActuatorMockRecorder struct {
	mock *MockActuator
}

// NewMockActuator creates a new mock instance.
func NewMockActuator(ctrl *gomock.Controller) *MockActuator {
	mock := &MockActuator{ctrl: ctrl}
	mock.recorder = &MockActuatorMockRecorder{mock}
	return mock
}

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

// Reconcile mocks base method.
func (m *MockActuator) Reconcile(arg0 context.Context, arg1 *v1alpha1.ManagedSeedSet) (*v1alpha1.ManagedSeedSetStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Reconcile", arg0, arg1)
	ret0, _ := ret[0].(*v1alpha1.ManagedSeedSetStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockReplica is a mock of Replica interface.
type MockReplica struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaMockRecorder
}

// MockReplicaMockRecorder is the mock recorder for MockReplica.
type MockReplicaMockRecorder struct {
	mock *MockReplica
}

// NewMockReplica creates a new mock instance.
func NewMockReplica(ctrl *gomock.Controller) *MockReplica {
	mock := &MockReplica{ctrl: ctrl}
	mock.recorder = &MockReplicaMockRecorder{mock}
	return mock
}

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

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

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

// CreateShoot mocks base method.
func (m *MockReplica) CreateShoot(arg0 context.Context, arg1 client.Client, arg2 int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateShoot", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

// GetFullName indicates an expected call of GetFullName.
func (mr *MockReplicaMockRecorder) GetFullName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFullName", reflect.TypeOf((*MockReplica)(nil).GetFullName))
}

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

// GetName indicates an expected call of GetName.
func (mr *MockReplicaMockRecorder) GetName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetName", reflect.TypeOf((*MockReplica)(nil).GetName))
}

// GetOrdinal mocks base method.
func (m *MockReplica) GetOrdinal() int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrdinal")
	ret0, _ := ret[0].(int)
	return ret0
}

// GetOrdinal indicates an expected call of GetOrdinal.
func (mr *MockReplicaMockRecorder) GetOrdinal() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrdinal", reflect.TypeOf((*MockReplica)(nil).GetOrdinal))
}

// GetShootHealthStatus mocks base method.
func (m *MockReplica) GetShootHealthStatus() shoot.Status {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetShootHealthStatus")
	ret0, _ := ret[0].(shoot.Status)
	return ret0
}

// GetShootHealthStatus indicates an expected call of GetShootHealthStatus.
func (mr *MockReplicaMockRecorder) GetShootHealthStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetShootHealthStatus", reflect.TypeOf((*MockReplica)(nil).GetShootHealthStatus))
}

// GetStatus mocks base method.
func (m *MockReplica) GetStatus() managedseedset.ReplicaStatus {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStatus")
	ret0, _ := ret[0].(managedseedset.ReplicaStatus)
	return ret0
}

// GetStatus indicates an expected call of GetStatus.
func (mr *MockReplicaMockRecorder) GetStatus() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStatus", reflect.TypeOf((*MockReplica)(nil).GetStatus))
}

// IsDeletable mocks base method.
func (m *MockReplica) IsDeletable() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsDeletable")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsDeletable indicates an expected call of IsDeletable.
func (mr *MockReplicaMockRecorder) IsDeletable() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDeletable", reflect.TypeOf((*MockReplica)(nil).IsDeletable))
}

// IsSeedReady mocks base method.
func (m *MockReplica) IsSeedReady() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsSeedReady")
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsSeedReady indicates an expected call of IsSeedReady.
func (mr *MockReplicaMockRecorder) IsSeedReady() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsSeedReady", reflect.TypeOf((*MockReplica)(nil).IsSeedReady))
}

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

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

// MockReplicaFactory is a mock of ReplicaFactory interface.
type MockReplicaFactory struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaFactoryMockRecorder
}

// MockReplicaFactoryMockRecorder is the mock recorder for MockReplicaFactory.
type MockReplicaFactoryMockRecorder struct {
	mock *MockReplicaFactory
}

// NewMockReplicaFactory creates a new mock instance.
func NewMockReplicaFactory(ctrl *gomock.Controller) *MockReplicaFactory {
	mock := &MockReplicaFactory{ctrl: ctrl}
	mock.recorder = &MockReplicaFactoryMockRecorder{mock}
	return mock
}

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

// NewReplica mocks base method.
func (m *MockReplicaFactory) NewReplica(arg0 *v1alpha1.ManagedSeedSet, arg1 *v1beta1.Shoot, arg2 *v1alpha1.ManagedSeed, arg3 *v1beta1.Seed, arg4 bool) managedseedset.Replica {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReplica", arg0, arg1, arg2, arg3, arg4)
	ret0, _ := ret[0].(managedseedset.Replica)
	return ret0
}

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

// MockReplicaGetter is a mock of ReplicaGetter interface.
type MockReplicaGetter struct {
	ctrl     *gomock.Controller
	recorder *MockReplicaGetterMockRecorder
}

// MockReplicaGetterMockRecorder is the mock recorder for MockReplicaGetter.
type MockReplicaGetterMockRecorder struct {
	mock *MockReplicaGetter
}

// NewMockReplicaGetter creates a new mock instance.
func NewMockReplicaGetter(ctrl *gomock.Controller) *MockReplicaGetter {
	mock := &MockReplicaGetter{ctrl: ctrl}
	mock.recorder = &MockReplicaGetterMockRecorder{mock}
	return mock
}

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

// GetReplicas mocks base method.
func (m *MockReplicaGetter) GetReplicas(arg0 context.Context, arg1 *v1alpha1.ManagedSeedSet) ([]managedseedset.Replica, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReplicas", arg0, arg1)
	ret0, _ := ret[0].([]managedseedset.Replica)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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