factory.go

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

package clients_test

import (
	io "io"
	"reflect"
	"time"

	versioned "github.com/banzaicloud/bank-vaults/operator/pkg/client/clientset/versioned"
	client "github.com/heptio/sonobuoy/pkg/client"
	golang_jenkins "github.com/jenkins-x/golang-jenkins"
	auth "github.com/jenkins-x/jx/v2/pkg/auth"
	versioned0 "github.com/jenkins-x/jx/v2/pkg/client/clientset/versioned"
	clients "github.com/jenkins-x/jx/v2/pkg/cmd/clients"
	gits "github.com/jenkins-x/jx/v2/pkg/gits"
	helm "github.com/jenkins-x/jx/v2/pkg/helm"
	secrets "github.com/jenkins-x/jx/v2/pkg/io/secrets"
	kustomize "github.com/jenkins-x/jx/v2/pkg/kustomize"
	table "github.com/jenkins-x/jx/v2/pkg/table"
	util "github.com/jenkins-x/jx/v2/pkg/util"
	vault "github.com/jenkins-x/jx/v2/pkg/vault"
	versioned1 "github.com/jetstack/cert-manager/pkg/client/clientset/versioned"
	versioned2 "github.com/knative/serving/pkg/client/clientset/versioned"
	pegomock "github.com/petergtz/pegomock"
	versioned3 "github.com/tektoncd/pipeline/pkg/client/clientset/versioned"
	clientset "k8s.io/apiextensions-apiserver/pkg/client/clientset/clientset"
	dynamic "k8s.io/client-go/dynamic"
	kubernetes "k8s.io/client-go/kubernetes"
	rest "k8s.io/client-go/rest"
	versioned4 "k8s.io/metrics/pkg/client/clientset/versioned"
	versioned5 "k8s.io/test-infra/prow/client/clientset/versioned"
)

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

func NewMockFactory(options ...pegomock.Option) *MockFactory {
	mock := &MockFactory{}
	for _, option := range options {
		option.Apply(mock)
	}
	return mock
}

func (mock *MockFactory) SetFailHandler(fh pegomock.FailHandler) { mock.fail = fh }
func (mock *MockFactory) FailHandler() pegomock.FailHandler      { return mock.fail }

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

func (mock *MockFactory) CreateChartmuseumAuthConfigService(_param0 string, _param1 string) (auth.ConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	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 string, _param1 string) (auth.ConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	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 util.IOFileHandles) (golang_jenkins.JenkinsClient, 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("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.Interface, 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.Interface)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 dynamic.Interface
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(dynamic.Interface)
		}
		if result[1] != nil {
			ret1 = result[1].(string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockFactory) CreateExternalVaultClient(_param0 vault.Vault, _param1 kubernetes.Interface) (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("CreateExternalVaultClient", 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) CreateGitAuthConfigService(_param0 string, _param1 string) (auth.ConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateGitAuthConfigService", 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) CreateGitProvider(_param0 string, _param1 string, _param2 auth.ConfigService, _param3 string, _param4 string, _param5 bool, _param6 gits.Gitter, _param7 util.IOFileHandles) (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}
	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) CreateInternalVaultClient(_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("CreateInternalVaultClient", 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) CreateIssueTrackerAuthConfigService(_param0 string, _param1 string) (auth.ConfigService, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1}
	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 string, _param1 string) (auth.ConfigService, 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.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 util.IOFileHandles) (golang_jenkins.JenkinsClient, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	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) CreateKnativeServeClient() (versioned2.Interface, string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateKnativeServeClient", params, []reflect.Type{reflect.TypeOf((*versioned2.Interface)(nil)).Elem(), reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 versioned2.Interface
	var ret1 string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(versioned2.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) CreateKustomizer() kustomize.Kustomizer {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockFactory().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateKustomizer", params, []reflect.Type{reflect.TypeOf((*kustomize.Kustomizer)(nil)).Elem()})
	var ret0 kustomize.Kustomizer
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(kustomize.Kustomizer)
		}
	}
	return ret0
}

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

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) CreateVaultOperatorClient() (versioned.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((*versioned.Interface)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 versioned.Interface
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(versioned.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) 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() *VerifierMockFactory {
	return &VerifierMockFactory{
		mock:                   mock,
		invocationCountMatcher: pegomock.Times(1),
	}
}

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

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

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

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

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

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

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

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

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

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

func (c *MockFactory_CreateApiExtensionsClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateApiExtensionsClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

func (c *MockFactory_CreateCertManagerClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateCertManagerClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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

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

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

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

func (c *MockFactory_CreateComplianceClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateComplianceClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockFactory) CreateCustomJenkinsClient(_param0 kubernetes.Interface, _param1 string, _param2 string, _param3 util.IOFileHandles) *MockFactory_CreateCustomJenkinsClient_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateCustomJenkinsClient", params, verifier.timeout)
	return &MockFactory_CreateCustomJenkinsClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *MockFactory_CreateCustomJenkinsClient_OngoingVerification) GetCapturedArguments() (kubernetes.Interface, string, string, util.IOFileHandles) {
	_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 *MockFactory_CreateCustomJenkinsClient_OngoingVerification) GetAllCapturedArguments() (_param0 []kubernetes.Interface, _param1 []string, _param2 []string, _param3 []util.IOFileHandles) {
	params := pegomock.GetGenericMockFrom(c.mock).GetInvocationParams(c.methodInvocations)
	if len(params) > 0 {
		_param0 = make([]kubernetes.Interface, len(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(kubernetes.Interface)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
		_param3 = make([]util.IOFileHandles, len(c.methodInvocations))
		for u, param := range params[3] {
			_param3[u] = param.(util.IOFileHandles)
		}
	}
	return
}

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

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

func (c *MockFactory_CreateDynamicClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateDynamicClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockFactory) CreateExternalVaultClient(_param0 vault.Vault, _param1 kubernetes.Interface) *MockFactory_CreateExternalVaultClient_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateExternalVaultClient", params, verifier.timeout)
	return &MockFactory_CreateExternalVaultClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

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

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

func (verifier *VerifierMockFactory) CreateGitProvider(_param0 string, _param1 string, _param2 auth.ConfigService, _param3 string, _param4 string, _param5 bool, _param6 gits.Gitter, _param7 util.IOFileHandles) *MockFactory_CreateGitProvider_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateGitProvider", params, verifier.timeout)
	return &MockFactory_CreateGitProvider_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *MockFactory_CreateGitProvider_OngoingVerification) GetCapturedArguments() (string, string, auth.ConfigService, string, string, bool, gits.Gitter, util.IOFileHandles) {
	_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7 := 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]
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *MockFactory_CreateJXClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateJXClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

func (verifier *VerifierMockFactory) CreateJenkinsClient(_param0 kubernetes.Interface, _param1 string, _param2 util.IOFileHandles) *MockFactory_CreateJenkinsClient_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateJenkinsClient", params, verifier.timeout)
	return &MockFactory_CreateJenkinsClient_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

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

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

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

func (c *MockFactory_CreateKnativeServeClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateKnativeServeClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateKubeClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateKubeClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateKubeConfig_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateKubeConfig_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateKustomizer_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateKustomizer_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateLocalGitAuthConfigService_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateLocalGitAuthConfigService_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateMetricsClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateMetricsClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateProwJobClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateProwJobClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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

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

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

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

func (c *MockFactory_CreateTektonClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateTektonClient_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_CreateVaultOperatorClient_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_CreateVaultOperatorClient_OngoingVerification) GetAllCapturedArguments() {
}

func (verifier *VerifierMockFactory) GetCustomJenkinsURL(_param0 kubernetes.Interface, _param1 string, _param2 string) *MockFactory_GetCustomJenkinsURL_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetCustomJenkinsURL", params, verifier.timeout)
	return &MockFactory_GetCustomJenkinsURL_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

func (c *MockFactory_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 *MockFactory_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(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(kubernetes.Interface)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
		_param2 = make([]string, len(c.methodInvocations))
		for u, param := range params[2] {
			_param2[u] = param.(string)
		}
	}
	return
}

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

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

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

func (c *MockFactory_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(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(kubernetes.Interface)
		}
		_param1 = make([]string, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(string)
		}
	}
	return
}

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

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

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

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

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

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

func (c *MockFactory_IsInCDPipeline_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_IsInCDPipeline_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_ResetSecretsLocation_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_ResetSecretsLocation_OngoingVerification) GetAllCapturedArguments() {
}

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

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

func (c *MockFactory_SecretsLocation_OngoingVerification) GetCapturedArguments() {
}

func (c *MockFactory_SecretsLocation_OngoingVerification) GetAllCapturedArguments() {
}

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

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

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

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

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

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

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

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

func (verifier *VerifierMockFactory) SetSecretsLocation(_param0 secrets.SecretsLocationKind, _param1 bool) *MockFactory_SetSecretsLocation_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "SetSecretsLocation", params, verifier.timeout)
	return &MockFactory_SetSecretsLocation_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

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

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

func (c *MockFactory_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(c.methodInvocations))
		for u, param := range params[0] {
			_param0[u] = param.(secrets.SecretsLocationKind)
		}
		_param1 = make([]bool, len(c.methodInvocations))
		for u, param := range params[1] {
			_param1[u] = param.(bool)
		}
	}
	return
}

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

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

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

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