factory.go

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

package cmd_test

import (
	versioned0 "github.com/banzaicloud/bank-vaults/operator/pkg/client/clientset/versioned"
	client "github.com/heptio/sonobuoy/pkg/client"
	dynamic "github.com/heptio/sonobuoy/pkg/dynamic"
	golang_jenkins "github.com/jenkins-x/golang-jenkins"
	auth "github.com/jenkins-x/jx/pkg/auth"
	versioned1 "github.com/jenkins-x/jx/pkg/client/clientset/versioned"
	gits "github.com/jenkins-x/jx/pkg/gits"
	helm "github.com/jenkins-x/jx/pkg/helm"
	cmd "github.com/jenkins-x/jx/pkg/jx/cmd"
	table "github.com/jenkins-x/jx/pkg/table"
	versioned "github.com/knative/build/pkg/client/clientset/versioned"
	pegomock "github.com/petergtz/pegomock"
	terminal "gopkg.in/AlecAivazis/survey.v1/terminal"
	io "io"
	v1 "k8s.io/api/core/v1"
	clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
	kubernetes "k8s.io/client-go/kubernetes"
	rest "k8s.io/client-go/rest"
	clientset0 "k8s.io/metrics/pkg/client/clientset_generated/clientset"
	"reflect"
)

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

func NewMockFactory() *MockFactory {
	return &MockFactory{fail: pegomock.GlobalFailHandler}
}

func (mock *MockFactory) AuthMergePipelineSecrets(_param0 *auth.AuthConfig, _param1 *v1.SecretList, _param2 string, _param3 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("AuthMergePipelineSecrets", 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 *MockFactory) CreateAddonAuthConfigService(_param0 *v1.SecretList) (auth.AuthConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateAddonAuthConfigService", params, []reflect.Type{reflect.TypeOf((*auth.AuthConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.AuthConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.AuthConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

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

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

func (mock *MockFactory) CreateChatAuthConfigService(_param0 *v1.SecretList) (auth.AuthConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateChatAuthConfigService", params, []reflect.Type{reflect.TypeOf((*auth.AuthConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.AuthConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.AuthConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

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

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

func (mock *MockFactory) CreateGitProvider(_param0 string, _param1 string, _param2 auth.AuthConfigService, _param3 string, _param4 bool, _param5 gits.Gitter, _param6 terminal.FileReader, _param7 terminal.FileWriter, _param8 io.Writer) (gits.GitProvider, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateGitProvider", params, []reflect.Type{reflect.TypeOf((*gits.GitProvider)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 gits.GitProvider
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(gits.GitProvider)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockFactory) CreateIssueTrackerAuthConfigService(_param0 *v1.SecretList) (auth.AuthConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateIssueTrackerAuthConfigService", params, []reflect.Type{reflect.TypeOf((*auth.AuthConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.AuthConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.AuthConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

func (mock *MockFactory) CreateJenkinsAuthConfigService(_param0 kubernetes.Interface, _param1 string) (auth.AuthConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateJenkinsAuthConfigService", params, []reflect.Type{reflect.TypeOf((*auth.AuthConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.AuthConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.AuthConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockFactory) CreateJenkinsClient(_param0 kubernetes.Interface, _param1 string, _param2 terminal.FileReader, _param3 terminal.FileWriter, _param4 io.Writer) (golang_jenkins.JenkinsClient, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateJenkinsClient", params, []reflect.Type{reflect.TypeOf((*golang_jenkins.JenkinsClient)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 golang_jenkins.JenkinsClient
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(golang_jenkins.JenkinsClient)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

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

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

func (mock *MockFactory) CreateTable(_param0 io.Writer) table.Table {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateTable", params, []reflect.Type{reflect.TypeOf((*table.Table)(nil)).Elem()})
	var ret0 table.Table
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(table.Table)
		}
	}
	return ret0
}

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

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

func (mock *MockFactory) GetJenkinsURL(_param0 kubernetes.Interface, _param1 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetJenkinsURL", 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 *MockFactory) ImpersonateUser(_param0 string) cmd.Factory {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ImpersonateUser", params, []reflect.Type{reflect.TypeOf((*cmd.Factory)(nil)).Elem()})
	var ret0 cmd.Factory
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(cmd.Factory)
		}
	}
	return ret0
}

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

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

func (mock *MockFactory) SetBatch(_param0 bool) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	pegomock.GetGenericMockFrom(mock).Invoke("SetBatch", params, []reflect.Type{})
}

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

func (mock *MockFactory) VerifyWasCalledOnce() *VerifierFactory {
	return &VerifierFactory{mock, pegomock.Times(1), nil}
}

func (mock *MockFactory) VerifyWasCalled(invocationCountMatcher pegomock.Matcher) *VerifierFactory {
	return &VerifierFactory{mock, invocationCountMatcher, nil}
}

func (mock *MockFactory) VerifyWasCalledInOrder(invocationCountMatcher pegomock.Matcher, inOrderContext *pegomock.InOrderContext) *VerifierFactory {
	return &VerifierFactory{mock, invocationCountMatcher, inOrderContext}
}

type VerifierFactory struct {
	mock                   *MockFactory
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
}

func (verifier *VerifierFactory) AuthMergePipelineSecrets(_param0 *auth.AuthConfig, _param1 *v1.SecretList, _param2 string, _param3 bool) *Factory_AuthMergePipelineSecrets_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "AuthMergePipelineSecrets", params)
	return &Factory_AuthMergePipelineSecrets_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_AuthMergePipelineSecrets_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_AuthMergePipelineSecrets_OngoingVerification) GetCapturedArguments() (*auth.AuthConfig, *v1.SecretList, 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 *Factory_AuthMergePipelineSecrets_OngoingVerification) GetAllCapturedArguments() (_param0 []*auth.AuthConfig, _param1 []*v1.SecretList, _param2 []string, _param3 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]*auth.AuthConfig, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(*auth.AuthConfig)
		}
		_param1 = make([]*v1.SecretList, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(*v1.SecretList)
		}
		_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 *VerifierFactory) CreateAddonAuthConfigService(_param0 *v1.SecretList) *Factory_CreateAddonAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateAddonAuthConfigService", params)
	return &Factory_CreateAddonAuthConfigService_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateAddonAuthConfigService_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateAddonAuthConfigService_OngoingVerification) GetCapturedArguments() *v1.SecretList {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierFactory) CreateApiExtensionsClient() *Factory_CreateApiExtensionsClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateApiExtensionsClient", params)
	return &Factory_CreateApiExtensionsClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateApiExtensionsClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateApiExtensionsClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateApiExtensionsClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateAuthConfigService(_param0 string) *Factory_CreateAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateAuthConfigService", params)
	return &Factory_CreateAuthConfigService_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateAuthConfigService_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *Factory_CreateAuthConfigService_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 *VerifierFactory) CreateChartmuseumAuthConfigService() *Factory_CreateChartmuseumAuthConfigService_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateChartmuseumAuthConfigService", params)
	return &Factory_CreateChartmuseumAuthConfigService_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateChartmuseumAuthConfigService_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateChartmuseumAuthConfigService_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateChartmuseumAuthConfigService_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateChatAuthConfigService(_param0 *v1.SecretList) *Factory_CreateChatAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateChatAuthConfigService", params)
	return &Factory_CreateChatAuthConfigService_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateChatAuthConfigService_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateChatAuthConfigService_OngoingVerification) GetCapturedArguments() *v1.SecretList {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierFactory) CreateClient() *Factory_CreateClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateClient", params)
	return &Factory_CreateClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateComplianceClient() *Factory_CreateComplianceClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateComplianceClient", params)
	return &Factory_CreateComplianceClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateComplianceClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateComplianceClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateComplianceClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateDynamicClient() *Factory_CreateDynamicClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateDynamicClient", params)
	return &Factory_CreateDynamicClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateDynamicClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateDynamicClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateDynamicClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateGitProvider(_param0 string, _param1 string, _param2 auth.AuthConfigService, _param3 string, _param4 bool, _param5 gits.Gitter, _param6 terminal.FileReader, _param7 terminal.FileWriter, _param8 io.Writer) *Factory_CreateGitProvider_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateGitProvider", params)
	return &Factory_CreateGitProvider_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateGitProvider_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateGitProvider_OngoingVerification) GetCapturedArguments() (string, string, auth.AuthConfigService, string, bool, gits.Gitter, terminal.FileReader, terminal.FileWriter, io.Writer) {
	_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7, _param8 := 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]
}

func (c *Factory_CreateGitProvider_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []auth.AuthConfigService, _param3 []string, _param4 []bool, _param5 []gits.Gitter, _param6 []terminal.FileReader, _param7 []terminal.FileWriter, _param8 []io.Writer) {
	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([]auth.AuthConfigService, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(auth.AuthConfigService)
		}
		_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([]gits.Gitter, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.(gits.Gitter)
		}
		_param6 = make([]terminal.FileReader, len(params[6]))
		for u, param := range params[6] {
			_param6[u] = param.(terminal.FileReader)
		}
		_param7 = make([]terminal.FileWriter, len(params[7]))
		for u, param := range params[7] {
			_param7[u] = param.(terminal.FileWriter)
		}
		_param8 = make([]io.Writer, len(params[8]))
		for u, param := range params[8] {
			_param8[u] = param.(io.Writer)
		}
	}
	return
}

func (verifier *VerifierFactory) CreateIssueTrackerAuthConfigService(_param0 *v1.SecretList) *Factory_CreateIssueTrackerAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateIssueTrackerAuthConfigService", params)
	return &Factory_CreateIssueTrackerAuthConfigService_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateIssueTrackerAuthConfigService_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateIssueTrackerAuthConfigService_OngoingVerification) GetCapturedArguments() *v1.SecretList {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierFactory) CreateJXClient() *Factory_CreateJXClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJXClient", params)
	return &Factory_CreateJXClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateJXClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateJXClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateJXClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateJenkinsAuthConfigService(_param0 kubernetes.Interface, _param1 string) *Factory_CreateJenkinsAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJenkinsAuthConfigService", params)
	return &Factory_CreateJenkinsAuthConfigService_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateJenkinsAuthConfigService_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierFactory) CreateJenkinsClient(_param0 kubernetes.Interface, _param1 string, _param2 terminal.FileReader, _param3 terminal.FileWriter, _param4 io.Writer) *Factory_CreateJenkinsClient_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJenkinsClient", params)
	return &Factory_CreateJenkinsClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateJenkinsClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateJenkinsClient_OngoingVerification) GetCapturedArguments() (kubernetes.Interface, string, terminal.FileReader, terminal.FileWriter, io.Writer) {
	_param0, _param1, _param2, _param3, _param4 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1], _param3[len(_param3)-1], _param4[len(_param4)-1]
}

func (c *Factory_CreateJenkinsClient_OngoingVerification) GetAllCapturedArguments() (_param0 []kubernetes.Interface, _param1 []string, _param2 []terminal.FileReader, _param3 []terminal.FileWriter, _param4 []io.Writer) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]kubernetes.Interface, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(kubernetes.Interface)
		}
		_param1 = make([]string, len(params[1]))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]terminal.FileReader, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(terminal.FileReader)
		}
		_param3 = make([]terminal.FileWriter, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(terminal.FileWriter)
		}
		_param4 = make([]io.Writer, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(io.Writer)
		}
	}
	return
}

func (verifier *VerifierFactory) CreateKnativeBuildClient() *Factory_CreateKnativeBuildClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateKnativeBuildClient", params)
	return &Factory_CreateKnativeBuildClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateKnativeBuildClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateKnativeBuildClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateKnativeBuildClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateKubeConfig() *Factory_CreateKubeConfig_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateKubeConfig", params)
	return &Factory_CreateKubeConfig_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateKubeConfig_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateKubeConfig_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateKubeConfig_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateMetricsClient() *Factory_CreateMetricsClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateMetricsClient", params)
	return &Factory_CreateMetricsClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateMetricsClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateMetricsClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateMetricsClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateTable(_param0 io.Writer) *Factory_CreateTable_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateTable", params)
	return &Factory_CreateTable_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateTable_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateTable_OngoingVerification) GetCapturedArguments() io.Writer {
	_param0 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1]
}

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

func (verifier *VerifierFactory) CreateVaultOperatorClient() *Factory_CreateVaultOperatorClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateVaultOperatorClient", params)
	return &Factory_CreateVaultOperatorClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_CreateVaultOperatorClient_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_CreateVaultOperatorClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateVaultOperatorClient_OngoingVerification) GetAllCapturedArguments() {
}

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

type Factory_GetHelm_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_GetHelm_OngoingVerification) GetCapturedArguments() (bool, string, bool, 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 *Factory_GetHelm_OngoingVerification) GetAllCapturedArguments() (_param0 []bool, _param1 []string, _param2 []bool, _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([]bool, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(bool)
		}
		_param3 = make([]bool, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(bool)
		}
	}
	return
}

func (verifier *VerifierFactory) GetJenkinsURL(_param0 kubernetes.Interface, _param1 string) *Factory_GetJenkinsURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetJenkinsURL", params)
	return &Factory_GetJenkinsURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_GetJenkinsURL_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

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

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

func (verifier *VerifierFactory) ImpersonateUser(_param0 string) *Factory_ImpersonateUser_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ImpersonateUser", params)
	return &Factory_ImpersonateUser_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_ImpersonateUser_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *Factory_ImpersonateUser_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 *VerifierFactory) IsInCDPipeline() *Factory_IsInCDPipeline_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsInCDPipeline", params)
	return &Factory_IsInCDPipeline_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_IsInCDPipeline_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_IsInCDPipeline_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_IsInCDPipeline_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) IsInCluster() *Factory_IsInCluster_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsInCluster", params)
	return &Factory_IsInCluster_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_IsInCluster_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

func (c *Factory_IsInCluster_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_IsInCluster_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) SetBatch(_param0 bool) *Factory_SetBatch_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetBatch", params)
	return &Factory_SetBatch_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_SetBatch_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *Factory_SetBatch_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
}

func (verifier *VerifierFactory) WithBearerToken(_param0 string) *Factory_WithBearerToken_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "WithBearerToken", params)
	return &Factory_WithBearerToken_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type Factory_WithBearerToken_OngoingVerification struct {
	mock              *MockFactory
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *Factory_WithBearerToken_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
}