func (mr *MockLayerApplierMockRecorder) GetHelmReleases(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHelmReleases", reflect.TypeOf((*MockLayerApplier)(nil).GetHelmReleases), ctx, layer)
}
GetHelmReleases indicates an expected call of GetHelmReleases
package mocks
import (
	context "context"
	v1alpha1 "github.com/fidelity/kraan/api/v1alpha1"
	layers "github.com/fidelity/kraan/pkg/layers"
	v2beta1 "github.com/fluxcd/helm-controller/api/v2beta1"
	gomock "github.com/golang/mock/gomock"
	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	runtime "k8s.io/apimachinery/pkg/runtime"
	reflect "reflect"
)
type MockLayerApplier struct {
	ctrl     *gomock.Controller
	recorder *MockLayerApplierMockRecorder
}
type MockLayerApplierMockRecorder struct {
	mock *MockLayerApplier
}
func NewMockLayerApplier(ctrl *gomock.Controller) *MockLayerApplier {
	mock := &MockLayerApplier{ctrl: ctrl}
	mock.recorder = &MockLayerApplierMockRecorder{mock}
	return mock
}
func (m *MockLayerApplier) EXPECT() *MockLayerApplierMockRecorder {
	return m.recorder
}
func (m *MockLayerApplier) Apply(ctx context.Context, layer layers.Layer) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Apply", ctx, layer)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockLayerApplierMockRecorder) Apply(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Apply", reflect.TypeOf((*MockLayerApplier)(nil).Apply), ctx, layer)
}
func (m *MockLayerApplier) Prune(ctx context.Context, layer layers.Layer, pruneHrs []*v2beta1.HelmRelease) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prune", ctx, layer, pruneHrs)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockLayerApplierMockRecorder) Prune(ctx, layer, pruneHrs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prune", reflect.TypeOf((*MockLayerApplier)(nil).Prune), ctx, layer, pruneHrs)
}
func (m *MockLayerApplier) PruneIsRequired(ctx context.Context, layer layers.Layer) (bool, []*v2beta1.HelmRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PruneIsRequired", ctx, layer)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].([]*v2beta1.HelmRelease)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockLayerApplierMockRecorder) PruneIsRequired(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PruneIsRequired", reflect.TypeOf((*MockLayerApplier)(nil).PruneIsRequired), ctx, layer)
}
func (m *MockLayerApplier) ApplyIsRequired(ctx context.Context, layer layers.Layer) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyIsRequired", ctx, layer)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockLayerApplierMockRecorder) ApplyIsRequired(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyIsRequired", reflect.TypeOf((*MockLayerApplier)(nil).ApplyIsRequired), ctx, layer)
}
func (m *MockLayerApplier) ApplyWasSuccessful(ctx context.Context, layer layers.Layer) (bool, string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyWasSuccessful", ctx, layer)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(string)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockLayerApplierMockRecorder) ApplyWasSuccessful(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyWasSuccessful", reflect.TypeOf((*MockLayerApplier)(nil).ApplyWasSuccessful), ctx, layer)
}
func (m *MockLayerApplier) GetResources(ctx context.Context, layer layers.Layer) ([]v1alpha1.Resource, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResources", ctx, layer)
	ret0, _ := ret[0].([]v1alpha1.Resource)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockLayerApplierMockRecorder) GetResources(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResources", reflect.TypeOf((*MockLayerApplier)(nil).GetResources), ctx, layer)
}
func (m *MockLayerApplier) GetSourceAndClusterHelmReleases(ctx context.Context, layer layers.Layer) (map[string]*v2beta1.HelmRelease, map[string]*v2beta1.HelmRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSourceAndClusterHelmReleases", ctx, layer)
	ret0, _ := ret[0].(map[string]*v2beta1.HelmRelease)
	ret1, _ := ret[1].(map[string]*v2beta1.HelmRelease)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockLayerApplierMockRecorder) GetSourceAndClusterHelmReleases(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceAndClusterHelmReleases", reflect.TypeOf((*MockLayerApplier)(nil).GetSourceAndClusterHelmReleases), ctx, layer)
}
func (m *MockLayerApplier) Orphan(ctx context.Context, layer layers.Layer, hr *v2beta1.HelmRelease) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Orphan", ctx, layer, hr)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockLayerApplierMockRecorder) Orphan(ctx, layer, hr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Orphan", reflect.TypeOf((*MockLayerApplier)(nil).Orphan), ctx, layer, hr)
}
func (m *MockLayerApplier) GetOrphanedHelmReleases(ctx context.Context, layer layers.Layer) (map[string]*v2beta1.HelmRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOrphanedHelmReleases", ctx, layer)
	ret0, _ := ret[0].(map[string]*v2beta1.HelmRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockLayerApplierMockRecorder) GetOrphanedHelmReleases(ctx, layer interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrphanedHelmReleases", reflect.TypeOf((*MockLayerApplier)(nil).GetOrphanedHelmReleases), ctx, layer)
}
func (m *MockLayerApplier) Adopt(ctx context.Context, layer layers.Layer, hr *v2beta1.HelmRelease) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Adopt", ctx, layer, hr)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockLayerApplierMockRecorder) Adopt(ctx, layer, hr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Adopt", reflect.TypeOf((*MockLayerApplier)(nil).Adopt), ctx, layer, hr)
}
func (m *MockLayerApplier) addOwnerRefs(layer layers.Layer, objs []runtime.Object) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "addOwnerRefs", layer, objs)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockLayerApplierMockRecorder) addOwnerRefs(layer, objs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "addOwnerRefs", reflect.TypeOf((*MockLayerApplier)(nil).addOwnerRefs), layer, objs)
}
func (m *MockLayerApplier) orphanLabel(ctx context.Context, hr *v2beta1.HelmRelease) (*v1.Time, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "orphanLabel", ctx, hr)
	ret0, _ := ret[0].(*v1.Time)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}
func (mr *MockLayerApplierMockRecorder) orphanLabel(ctx, hr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "orphanLabel", reflect.TypeOf((*MockLayerApplier)(nil).orphanLabel), ctx, hr)
}
func (m *MockLayerApplier) GetHelmReleases(ctx context.Context, layer layers.Layer) (map[string]*v2beta1.HelmRelease, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHelmReleases", ctx, layer)
	ret0, _ := ret[0].(map[string]*v2beta1.HelmRelease)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}