factory.go

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

package clients_test

import (
	versioned4 "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"
	versioned0 "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"
	secrets "github.com/jenkins-x/jx/pkg/io/secrets"
	clients "github.com/jenkins-x/jx/pkg/jx/cmd/clients"
	table "github.com/jenkins-x/jx/pkg/table"
	vault "github.com/jenkins-x/jx/pkg/vault"
	versioned2 "github.com/jetstack/cert-manager/pkg/client/clientset/versioned"
	versioned "github.com/knative/build/pkg/client/clientset/versioned"
	pegomock "github.com/petergtz/pegomock"
	versioned3 "github.com/tektoncd/pipeline/pkg/client/clientset/versioned"
	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"
	versioned1 "k8s.io/metrics/pkg/client/clientset/versioned"
	"reflect"
	"time"
)

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.ConfigService, 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.ConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.ConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.ConfigService)
		}
		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.ConfigService, 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.ConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.ConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.ConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

func (mock *MockFactory) CreateChartmuseumAuthConfigService() (auth.ConfigService, 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.ConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.ConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.ConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockFactory) CreateChatAuthConfigService(_param0 *v1.SecretList) (auth.ConfigService, 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.ConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.ConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.ConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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) CreateCustomJenkinsClient(_param0 kubernetes.Interface, _param1 string, _param2 string, _param3 terminal.FileReader, _param4 terminal.FileWriter, _param5 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, _param5}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateCustomJenkinsClient", 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) 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.ConfigService, _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) CreateHelm(_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("CreateHelm", 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) CreateIssueTrackerAuthConfigService(_param0 *v1.SecretList) (auth.ConfigService, 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.ConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.ConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.ConfigService)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockFactory) CreateJXClient() (versioned0.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((*versioned0.Interface)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 versioned0.Interface
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(versioned0.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, _param2 string) (auth.ConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateJenkinsAuthConfigService", params, []reflect.Type{reflect.TypeOf((*auth.ConfigService)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 auth.ConfigService
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(auth.ConfigService)
		}
		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) CreateKubeClient() (kubernetes.Interface, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateKubeClient", 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) 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() (*versioned1.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((**versioned1.Clientset)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 *versioned1.Clientset
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(*versioned1.Clientset)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockFactory) CreateSystemVaultClient(_param0 string) (vault.Client, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateSystemVaultClient", params, []reflect.Type{reflect.TypeOf((*vault.Client)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 vault.Client
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(vault.Client)
		}
		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) CreateTektonClient() (versioned3.Interface, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateTektonClient", params, []reflect.Type{reflect.TypeOf((*versioned3.Interface)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 versioned3.Interface
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(versioned3.Interface)
		}
		if result[1] != nil {
			ret1 = result[1].(string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

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

func (mock *MockFactory) CreateVaultOperatorClient() (versioned4.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((*versioned4.Interface)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 versioned4.Interface
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(versioned4.Interface)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

func (mock *MockFactory) SecretsLocation() secrets.SecretsLocationKind {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SecretsLocation", params, []reflect.Type{reflect.TypeOf((*secrets.SecretsLocationKind)(nil)).Elem()})
	var ret0 secrets.SecretsLocationKind
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(secrets.SecretsLocationKind)
		}
	}
	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) SetOffline(_param0 bool) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0}
	pegomock.GetGenericMockFrom(mock).Invoke("SetOffline", params, []reflect.Type{})
}

func (mock *MockFactory) SetSecretsLocation(_param0 secrets.SecretsLocationKind, _param1 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("SetSecretsLocation", 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) WithBearerToken(_param0 string) clients.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((*clients.Factory)(nil)).Elem()})
	var ret0 clients.Factory
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(clients.Factory)
		}
	}
	return ret0
}

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

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

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

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

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

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, verifier.timeout)
	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, verifier.timeout)
	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, verifier.timeout)
	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, verifier.timeout)
	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) CreateCertManagerClient() *Factory_CreateCertManagerClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateCertManagerClient", params, verifier.timeout)
	return &Factory_CreateCertManagerClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_CreateCertManagerClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateCertManagerClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateChartmuseumAuthConfigService() *Factory_CreateChartmuseumAuthConfigService_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateChartmuseumAuthConfigService", params, verifier.timeout)
	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, verifier.timeout)
	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) CreateComplianceClient() *Factory_CreateComplianceClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateComplianceClient", params, verifier.timeout)
	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) CreateCustomJenkinsClient(_param0 kubernetes.Interface, _param1 string, _param2 string, _param3 terminal.FileReader, _param4 terminal.FileWriter, _param5 io.Writer) *Factory_CreateCustomJenkinsClient_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateCustomJenkinsClient", params, verifier.timeout)
	return &Factory_CreateCustomJenkinsClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_CreateCustomJenkinsClient_OngoingVerification) GetCapturedArguments() (kubernetes.Interface, string, string, terminal.FileReader, terminal.FileWriter, io.Writer) {
	_param0, _param1, _param2, _param3, _param4, _param5 := 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]
}

func (c *Factory_CreateCustomJenkinsClient_OngoingVerification) GetAllCapturedArguments() (_param0 []kubernetes.Interface, _param1 []string, _param2 []string, _param3 []terminal.FileReader, _param4 []terminal.FileWriter, _param5 []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([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]terminal.FileReader, len(params[3]))
		for u, param := range params[3] {
			_param3[u] = param.(terminal.FileReader)
		}
		_param4 = make([]terminal.FileWriter, len(params[4]))
		for u, param := range params[4] {
			_param4[u] = param.(terminal.FileWriter)
		}
		_param5 = make([]io.Writer, len(params[5]))
		for u, param := range params[5] {
			_param5[u] = param.(io.Writer)
		}
	}
	return
}

func (verifier *VerifierFactory) CreateDynamicClient() *Factory_CreateDynamicClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateDynamicClient", params, verifier.timeout)
	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.ConfigService, _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, verifier.timeout)
	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.ConfigService, 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.ConfigService, _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.ConfigService, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(auth.ConfigService)
		}
		_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) CreateHelm(_param0 bool, _param1 string, _param2 bool, _param3 bool) *Factory_CreateHelm_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateHelm", params, verifier.timeout)
	return &Factory_CreateHelm_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_CreateHelm_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_CreateHelm_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) CreateIssueTrackerAuthConfigService(_param0 *v1.SecretList) *Factory_CreateIssueTrackerAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateIssueTrackerAuthConfigService", params, verifier.timeout)
	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, verifier.timeout)
	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, _param2 string) *Factory_CreateJenkinsAuthConfigService_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJenkinsAuthConfigService", params, verifier.timeout)
	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, string) {
	_param0, _param1, _param2 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1], _param2[len(_param2)-1]
}

func (c *Factory_CreateJenkinsAuthConfigService_OngoingVerification) GetAllCapturedArguments() (_param0 []kubernetes.Interface, _param1 []string, _param2 []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)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[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, verifier.timeout)
	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, verifier.timeout)
	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) CreateKubeClient() *Factory_CreateKubeClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateKubeClient", params, verifier.timeout)
	return &Factory_CreateKubeClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_CreateKubeClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateKubeClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierFactory) CreateKubeConfig() *Factory_CreateKubeConfig_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateKubeConfig", params, verifier.timeout)
	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, verifier.timeout)
	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) CreateSystemVaultClient(_param0 string) *Factory_CreateSystemVaultClient_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateSystemVaultClient", params, verifier.timeout)
	return &Factory_CreateSystemVaultClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

func (c *Factory_CreateSystemVaultClient_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) CreateTable(_param0 io.Writer) *Factory_CreateTable_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateTable", params, verifier.timeout)
	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) CreateTektonClient() *Factory_CreateTektonClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateTektonClient", params, verifier.timeout)
	return &Factory_CreateTektonClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_CreateTektonClient_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_CreateTektonClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

func (c *Factory_CreateVaultClient_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 *VerifierFactory) CreateVaultOperatorClient() *Factory_CreateVaultOperatorClient_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateVaultOperatorClient", params, verifier.timeout)
	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) GetCustomJenkinsURL(_param0 kubernetes.Interface, _param1 string, _param2 string) *Factory_GetCustomJenkinsURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCustomJenkinsURL", params, verifier.timeout)
	return &Factory_GetCustomJenkinsURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

func (c *Factory_GetCustomJenkinsURL_OngoingVerification) GetAllCapturedArguments() (_param0 []kubernetes.Interface, _param1 []string, _param2 []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)
		}
		_param2 = make([]string, len(params[2]))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	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, verifier.timeout)
	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, verifier.timeout)
	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, verifier.timeout)
	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, verifier.timeout)
	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) ResetSecretsLocation() *Factory_ResetSecretsLocation_OngoingVerification {
	params := []pegomock.Param{}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ResetSecretsLocation", params, verifier.timeout)
	return &Factory_ResetSecretsLocation_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_ResetSecretsLocation_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_ResetSecretsLocation_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *Factory_SecretsLocation_OngoingVerification) GetCapturedArguments() {
}

func (c *Factory_SecretsLocation_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, verifier.timeout)
	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) SetOffline(_param0 bool) *Factory_SetOffline_OngoingVerification {
	params := []pegomock.Param{_param0}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetOffline", params, verifier.timeout)
	return &Factory_SetOffline_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

func (c *Factory_SetOffline_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) SetSecretsLocation(_param0 secrets.SecretsLocationKind, _param1 bool) *Factory_SetSecretsLocation_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetSecretsLocation", params, verifier.timeout)
	return &Factory_SetSecretsLocation_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *Factory_SetSecretsLocation_OngoingVerification) GetCapturedArguments() (secrets.SecretsLocationKind, bool) {
	_param0, _param1 := c.GetAllCapturedArguments()
	return _param0[len(_param0)-1], _param1[len(_param1)-1]
}

func (c *Factory_SetSecretsLocation_OngoingVerification) GetAllCapturedArguments() (_param0 []secrets.SecretsLocationKind, _param1 []bool) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]secrets.SecretsLocationKind, len(params[0]))
		for u, param := range params[0] {
			_param0[u] = param.(secrets.SecretsLocationKind)
		}
		_param1 = make([]bool, len(params[1]))
		for u, param := range params[1] {
			_param1[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, verifier.timeout)
	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
}