helmer.go

// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/jenkins-x/jx/pkg/helm (interfaces: Helmer)

package helm_test

import (
	helm "github.com/jenkins-x/jx/pkg/helm"
	pegomock "github.com/petergtz/pegomock"
	"reflect"
	"time"
)

type MockHelmer struct {
	fail func(message string, callerSkip ...int)
}

func NewMockHelmer() *MockHelmer {
	return &MockHelmer{fail: pegomock.GlobalFailHandler}
}

func (mock *MockHelmer) AddRepo(_param0 string, _param1 string, _param2 string, _param3 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AddRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) BuildDependency() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("BuildDependency", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) DecryptSecrets(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DecryptSecrets", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) DeleteRelease(_param0 string, _param1 string, _param2 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteRelease", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) Env() map[string]string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Env", params, []reflect.Type{reflect.TypeOf((*map[string]string)(nil)).Elem()})
	var ret0 map[string]string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(map[string]string)
		}
	}
	return ret0
}

func (mock *MockHelmer) FetchChart(_param0 string, _param1 string, _param2 bool, _param3 string, _param4 string, _param5 string, _param6 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FetchChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) FindChart() (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FindChart", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) HelmBinary() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("HelmBinary", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

func (mock *MockHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Init", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 int, _param5 []string, _param6 []string, _param7 string, _param8 string, _param9 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9}
	result := pegomock.GetGenericMockFrom(mock).Invoke("InstallChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) IsRepoMissing(_param0 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsRepoMissing", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) Lint() (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Lint", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) ListCharts() (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListCharts", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) ListRepos() (map[string]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListRepos", params, []reflect.Type{reflect.TypeOf((*map[string]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 map[string]string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(map[string]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) PackageChart() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("PackageChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) RemoveRepo(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) RemoveRequirementsLock() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("RemoveRequirementsLock", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) SearchChartVersions(_param0 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SearchChartVersions", params, []reflect.Type{reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) SearchCharts(_param0 string) ([]helm.ChartSummary, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SearchCharts", params, []reflect.Type{reflect.TypeOf((*[]helm.ChartSummary)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []helm.ChartSummary
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]helm.ChartSummary)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) SetCWD(_param0 string) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	pegomock.GetGenericMockFrom(mock).Invoke("SetCWD", params, []reflect.Type{})
}

func (mock *MockHelmer) SetHelmBinary(_param0 string) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	pegomock.GetGenericMockFrom(mock).Invoke("SetHelmBinary", params, []reflect.Type{})
}

func (mock *MockHelmer) SetHost(_param0 string) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	pegomock.GetGenericMockFrom(mock).Invoke("SetHost", params, []reflect.Type{})
}

func (mock *MockHelmer) StatusRelease(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StatusRelease", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) StatusReleases(_param0 string) (map[string]helm.Release, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("StatusReleases", params, []reflect.Type{reflect.TypeOf((*map[string]helm.Release)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 map[string]helm.Release
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(map[string]helm.Release)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) UpdateRepo() error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateRepo", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) UpgradeChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 int, _param6 bool, _param7 bool, _param8 []string, _param9 []string, _param10 string, _param11 string, _param12 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpgradeChart", params, []reflect.Type{reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(error)
		}
	}
	return ret0
}

func (mock *MockHelmer) Version(_param0 bool) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockHelmer().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Version", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockHelmer) VerifyWasCalledOnce() *VerifierHelmer {
	return &VerifierHelmer{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

func (mock *MockHelmer) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierHelmer {
	return &VerifierHelmer{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
	}
}

func (mock *MockHelmer) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierHelmer {
	return &VerifierHelmer{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		inOrderContext:         inOrderContext,
	}
}

func (mock *MockHelmer) VerifyWasCalledEventually(invocationCountMatcher pegomock.Matcher, timeout time.Duration) *VerifierHelmer {
	return &VerifierHelmer{
		mock:                   mock,
		invocationCountMatcher: invocationCountMatcher,
		timeout:                timeout,
	}
}

type VerifierHelmer struct {
	mock                   *MockHelmer
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

func (verifier *VerifierHelmer) AddRepo(_param0 string, _param1 string, _param2 string, _param3 string) *Helmer_AddRepo_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AddRepo", params, verifier.timeout)
	return &Helmer_AddRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_AddRepo_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_AddRepo_OngoingVerification) GetCapturedArguments() (string, string, string, string) {
	_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}

func (c *Helmer_AddRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) BuildDependency() *Helmer_BuildDependency_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "BuildDependency", params, verifier.timeout)
	return &Helmer_BuildDependency_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_BuildDependency_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_BuildDependency_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_BuildDependency_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) DecryptSecrets(_param0 string) *Helmer_DecryptSecrets_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DecryptSecrets", params, verifier.timeout)
	return &Helmer_DecryptSecrets_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_DecryptSecrets_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_DecryptSecrets_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_DecryptSecrets_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) DeleteRelease(_param0 string, _param1 string, _param2 bool) *Helmer_DeleteRelease_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteRelease", params, verifier.timeout)
	return &Helmer_DeleteRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_DeleteRelease_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_DeleteRelease_OngoingVerification) GetCapturedArguments() (string, string, bool) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *Helmer_DeleteRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]bool, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierHelmer) Env() *Helmer_Env_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Env", params, verifier.timeout)
	return &Helmer_Env_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Env_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Env_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_Env_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) FetchChart(_param0 string, _param1 string, _param2 bool, _param3 string, _param4 string, _param5 string, _param6 string) *Helmer_FetchChart_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FetchChart", params, verifier.timeout)
	return &Helmer_FetchChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_FetchChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_FetchChart_OngoingVerification) GetCapturedArguments() (string, string, bool, string, string, string, string) {
	_param0, _param1, _param2, _param3, _param4, _param5, _param6 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1]
}

func (c *Helmer_FetchChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []bool, _param3 []string, _param4 []string, _param5 []string, _param6 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]bool, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(bool)
		}
		_param3 = make([]string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
		_param4 = make([]string, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(string)
		}
		_param5 = make([]string, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.(string)
		}
		_param6 = make([]string, len(params[6]))
		for u, param := range params[6] {
			_param6[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) FindChart() *Helmer_FindChart_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FindChart", params, verifier.timeout)
	return &Helmer_FindChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_FindChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_FindChart_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_FindChart_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) HelmBinary() *Helmer_HelmBinary_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "HelmBinary", params, verifier.timeout)
	return &Helmer_HelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_HelmBinary_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_HelmBinary_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_HelmBinary_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) Init(_param0 bool, _param1 string, _param2 string, _param3 bool) *Helmer_Init_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Init", params, verifier.timeout)
	return &Helmer_Init_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Init_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Init_OngoingVerification) GetCapturedArguments() (bool, string, string, bool) {
	_param0, _param1, _param2, _param3 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1]
}

func (c *Helmer_Init_OngoingVerification) GetAllCapturedArguments() (_param0 []bool, _param1 []string, _param2 []string, _param3 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]bool, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(bool)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]bool, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierHelmer) InstallChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 int, _param5 []string, _param6 []string, _param7 string, _param8 string, _param9 string) *Helmer_InstallChart_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "InstallChart", params, verifier.timeout)
	return &Helmer_InstallChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_InstallChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_InstallChart_OngoingVerification) GetCapturedArguments() (string, string, string, string, int, []string, []string, string, string, string) {
	_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1], _param7[len(_param7)-1], _param8[len(_param8)-1], _param9[len(_param9)-1]
}

func (c *Helmer_InstallChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string, _param4 []int, _param5 [][]string, _param6 [][]string, _param7 []string, _param8 []string, _param9 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
		_param4 = make([]int, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(int)
		}
		_param5 = make([][]string, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.([]string)
		}
		_param6 = make([][]string, len(params[6]))
		for u, param := range params[6] {
			_param6[u] = param.([]string)
		}
		_param7 = make([]string, len(params[7]))
		for u, param := range params[7] {
			_param7[u] = param.(string)
		}
		_param8 = make([]string, len(params[8]))
		for u, param := range params[8] {
			_param8[u] = param.(string)
		}
		_param9 = make([]string, len(params[9]))
		for u, param := range params[9] {
			_param9[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) IsRepoMissing(_param0 string) *Helmer_IsRepoMissing_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsRepoMissing", params, verifier.timeout)
	return &Helmer_IsRepoMissing_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_IsRepoMissing_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_IsRepoMissing_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_IsRepoMissing_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) Lint() *Helmer_Lint_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Lint", params, verifier.timeout)
	return &Helmer_Lint_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Lint_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Lint_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_Lint_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) ListCharts() *Helmer_ListCharts_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListCharts", params, verifier.timeout)
	return &Helmer_ListCharts_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_ListCharts_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_ListCharts_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_ListCharts_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) ListRepos() *Helmer_ListRepos_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListRepos", params, verifier.timeout)
	return &Helmer_ListRepos_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_ListRepos_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_ListRepos_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_ListRepos_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) PackageChart() *Helmer_PackageChart_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "PackageChart", params, verifier.timeout)
	return &Helmer_PackageChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_PackageChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_PackageChart_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_PackageChart_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) RemoveRepo(_param0 string) *Helmer_RemoveRepo_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRepo", params, verifier.timeout)
	return &Helmer_RemoveRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_RemoveRepo_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_RemoveRepo_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_RemoveRepo_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) RemoveRequirementsLock() *Helmer_RemoveRequirementsLock_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "RemoveRequirementsLock", params, verifier.timeout)
	return &Helmer_RemoveRequirementsLock_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_RemoveRequirementsLock_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_RemoveRequirementsLock_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_RemoveRequirementsLock_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) SearchChartVersions(_param0 string) *Helmer_SearchChartVersions_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchChartVersions", params, verifier.timeout)
	return &Helmer_SearchChartVersions_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SearchChartVersions_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SearchChartVersions_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SearchChartVersions_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SearchCharts(_param0 string) *Helmer_SearchCharts_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SearchCharts", params, verifier.timeout)
	return &Helmer_SearchCharts_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SearchCharts_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SearchCharts_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SearchCharts_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SetCWD(_param0 string) *Helmer_SetCWD_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetCWD", params, verifier.timeout)
	return &Helmer_SetCWD_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SetCWD_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SetCWD_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SetCWD_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SetHelmBinary(_param0 string) *Helmer_SetHelmBinary_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHelmBinary", params, verifier.timeout)
	return &Helmer_SetHelmBinary_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SetHelmBinary_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SetHelmBinary_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SetHelmBinary_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) SetHost(_param0 string) *Helmer_SetHost_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetHost", params, verifier.timeout)
	return &Helmer_SetHost_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_SetHost_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_SetHost_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_SetHost_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) StatusRelease(_param0 string, _param1 string) *Helmer_StatusRelease_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusRelease", params, verifier.timeout)
	return &Helmer_StatusRelease_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_StatusRelease_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_StatusRelease_OngoingVerification) GetCapturedArguments() (string, string) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *Helmer_StatusRelease_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) StatusReleases(_param0 string) *Helmer_StatusReleases_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "StatusReleases", params, verifier.timeout)
	return &Helmer_StatusReleases_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_StatusReleases_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_StatusReleases_OngoingVerification) GetCapturedArguments() string {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_StatusReleases_OngoingVerification) GetAllCapturedArguments() (_param0 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) UpdateRepo() *Helmer_UpdateRepo_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpdateRepo", params, verifier.timeout)
	return &Helmer_UpdateRepo_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_UpdateRepo_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_UpdateRepo_OngoingVerification) GetCapturedArguments() {
}

func (c *Helmer_UpdateRepo_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierHelmer) UpgradeChart(_param0 string, _param1 string, _param2 string, _param3 string, _param4 bool, _param5 int, _param6 bool, _param7 bool, _param8 []string, _param9 []string, _param10 string, _param11 string, _param12 string) *Helmer_UpgradeChart_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "UpgradeChart", params, verifier.timeout)
	return &Helmer_UpgradeChart_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_UpgradeChart_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_UpgradeChart_OngoingVerification) GetCapturedArguments() (string, string, string, string, bool, int, bool, bool, []string, []string, string, string, string) {
	_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8, _param9, _param10, _param11, _param12 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1], _param5[len(_param5)-1], _param6[len(_param6)-1], _param7[len(_param7)-1], _param8[len(_param8)-1], _param9[len(_param9)-1], _param10[len(_param10)-1], _param11[len(_param11)-1], _param12[len(_param12)-1]
}

func (c *Helmer_UpgradeChart_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []string, _param3 []string, _param4 []bool, _param5 []int, _param6 []bool, _param7 []bool, _param8 [][]string, _param9 [][]string, _param10 []string, _param11 []string, _param12 []string) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]string, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(string)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]string, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(string)
		}
		_param4 = make([]bool, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(bool)
		}
		_param5 = make([]int, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.(int)
		}
		_param6 = make([]bool, len(params[6]))
		for u, param := range params[6] {
			_param6[u] = param.(bool)
		}
		_param7 = make([]bool, len(params[7]))
		for u, param := range params[7] {
			_param7[u] = param.(bool)
		}
		_param8 = make([][]string, len(params[8]))
		for u, param := range params[8] {
			_param8[u] = param.([]string)
		}
		_param9 = make([][]string, len(params[9]))
		for u, param := range params[9] {
			_param9[u] = param.([]string)
		}
		_param10 = make([]string, len(params[10]))
		for u, param := range params[10] {
			_param10[u] = param.(string)
		}
		_param11 = make([]string, len(params[11]))
		for u, param := range params[11] {
			_param11[u] = param.(string)
		}
		_param12 = make([]string, len(params[12]))
		for u, param := range params[12] {
			_param12[u] = param.(string)
		}
	}
	return
}

func (verifier *VerifierHelmer) Version(_param0 bool) *Helmer_Version_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "Version", params, verifier.timeout)
	return &Helmer_Version_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Helmer_Version_OngoingVerification struct {
	mock              *MockHelmer
	methodInvocations []pegomock.MethodInvocation
}

func (c *Helmer_Version_OngoingVerification) GetCapturedArguments() bool {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

func (c *Helmer_Version_OngoingVerification) GetAllCapturedArguments() (_param0 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]bool, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(bool)
		}
	}
	return
}