github.com/jenkins-x/jx/v2@v2.1.155/pkg/cloud/gke/mocks/gclouder.go

// Code generated by pegomock. DO NOT EDIT.
// Source: github.com/jenkins-x/jx/v2/pkg/cloud/gke (interfaces: GClouder)

package gke_test

import (
	"reflect"
	"time"

	gke "github.com/jenkins-x/jx/v2/pkg/cloud/gke"
	pegomock "github.com/petergtz/pegomock"
	kubernetes "k8s.io/client-go/kubernetes"
)

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

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

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

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

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

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

func (mock *MockGClouder) CleanupServiceAccountKeys(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CleanupServiceAccountKeys", 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 *MockGClouder) ClusterZone(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ClusterZone", 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 *MockGClouder) ConfigureBucketRoles(_param0 string, _param1 string, _param2 string, _param3 []string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ConfigureBucketRoles", 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 *MockGClouder) ConnectToCluster(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ConnectToCluster", 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 *MockGClouder) ConnectToRegionCluster(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ConnectToRegionCluster", 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 *MockGClouder) CreateBucket(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateBucket", 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 *MockGClouder) CreateDNSZone(_param0 string, _param1 string) (string, []string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateDNSZone", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 []string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].([]string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockGClouder) CreateGCPServiceAccount(_param0 kubernetes.Interface, _param1 string, _param2 string, _param3 string, _param4 string, _param5 string, _param6 []string, _param7 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateGCPServiceAccount", 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 *MockGClouder) CreateKmsKey(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateKmsKey", 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 *MockGClouder) CreateKmsKeyring(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateKmsKeyring", 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 *MockGClouder) CreateManagedZone(_param0 string, _param1 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateManagedZone", 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 *MockGClouder) CreateServiceAccountKey(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("CreateServiceAccountKey", 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 *MockGClouder) DeleteAllObjectsInBucket(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteAllObjectsInBucket", 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 *MockGClouder) DeleteBucket(_param0 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteBucket", 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 *MockGClouder) DeleteServiceAccount(_param0 string, _param1 string, _param2 []string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteServiceAccount", 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 *MockGClouder) DeleteServiceAccountKey(_param0 string, _param1 string, _param2 string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("DeleteServiceAccountKey", 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 *MockGClouder) EnableAPIs(_param0 string, _param1 ...string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	for _, param := range _param1 {
		params = append(params, param)
	}
	result := pegomock.GetGenericMockFrom(mock).Invoke("EnableAPIs", 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 *MockGClouder) FindBucket(_param0 string) bool {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FindBucket", 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 *MockGClouder) FindServiceAccount(_param0 string, _param1 string) bool {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("FindServiceAccount", 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 *MockGClouder) GetEnabledApis(_param0 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetEnabledApis", 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 *MockGClouder) GetManagedZoneNameServers(_param0 string, _param1 string) (string, []string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetManagedZoneNameServers", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem(), reflect.TypeOf((*[]string)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 string
	var ret1 []string
	var ret2 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
		if result[1] != nil {
			ret1 = result[1].([]string)
		}
		if result[2] != nil {
			ret2 = result[2].(error)
		}
	}
	return ret0, ret1, ret2
}

func (mock *MockGClouder) GetOrCreateServiceAccount(_param0 string, _param1 string, _param2 string, _param3 []string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetOrCreateServiceAccount", 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 *MockGClouder) GetProjectNumber(_param0 string) (string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetProjectNumber", 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 *MockGClouder) GetServiceAccountKeys(_param0 string, _param1 string) ([]string, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("GetServiceAccountKeys", 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 *MockGClouder) IsGCSWriteRoleEnabled(_param0 string, _param1 string) (bool, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsGCSWriteRoleEnabled", params, []reflect.Type{reflect.TypeOf((*bool)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 bool
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(bool)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

func (mock *MockGClouder) IsKmsKeyAvailable(_param0 string, _param1 string, _param2 string) bool {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsKmsKeyAvailable", 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 *MockGClouder) IsKmsKeyringAvailable(_param0 string, _param1 string) bool {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("IsKmsKeyringAvailable", 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 *MockGClouder) ListClusters(_param0 string, _param1 string) ([]gke.Cluster, error) {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("ListClusters", params, []reflect.Type{reflect.TypeOf((*[]gke.Cluster)(nil)).Elem(), reflect.TypeOf((*error)(nil)).Elem()})
	var ret0 []gke.Cluster
	var ret1 error
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].([]gke.Cluster)
		}
		if result[1] != nil {
			ret1 = result[1].(error)
		}
	}
	return ret0, ret1
}

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

func (mock *MockGClouder) Login(_param0 string, _param1 bool) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1}
	result := pegomock.GetGenericMockFrom(mock).Invoke("Login", 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 *MockGClouder) UpdateGkeClusterLabels(_param0 string, _param1 string, _param2 string, _param3 []string) error {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UpdateGkeClusterLabels", 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 *MockGClouder) UserLabel() string {
	if mock == nil {
		panic("mock must not be nil. Use myMock := NewMockGClouder().")
	}
	params := []pegomock.Param{}
	result := pegomock.GetGenericMockFrom(mock).Invoke("UserLabel", params, []reflect.Type{reflect.TypeOf((*string)(nil)).Elem()})
	var ret0 string
	if len(result) != 0 {
		if result[0] != nil {
			ret0 = result[0].(string)
		}
	}
	return ret0
}

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

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

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

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

type VerifierMockGClouder struct {
	mock                   *MockGClouder
	invocationCountMatcher pegomock.Matcher
	inOrderContext         *pegomock.InOrderContext
	timeout                time.Duration
}

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

type MockGClouder_AddBucketLabel_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_AddBucketLabel_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 *VerifierMockGClouder) BucketExists(_param0 string, _param1 string) *MockGClouder_BucketExists_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "BucketExists", params, verifier.timeout)
	return &MockGClouder_BucketExists_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_BucketExists_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_BucketExists_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 *VerifierMockGClouder) CheckPermission(_param0 string, _param1 string) *MockGClouder_CheckPermission_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CheckPermission", params, verifier.timeout)
	return &MockGClouder_CheckPermission_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_CheckPermission_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CheckPermission_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 *VerifierMockGClouder) CleanupServiceAccountKeys(_param0 string, _param1 string) *MockGClouder_CleanupServiceAccountKeys_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CleanupServiceAccountKeys", params, verifier.timeout)
	return &MockGClouder_CleanupServiceAccountKeys_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_CleanupServiceAccountKeys_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

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

type MockGClouder_ClusterZone_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_ClusterZone_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 *VerifierMockGClouder) ConfigureBucketRoles(_param0 string, _param1 string, _param2 string, _param3 []string) *MockGClouder_ConfigureBucketRoles_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ConfigureBucketRoles", params, verifier.timeout)
	return &MockGClouder_ConfigureBucketRoles_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_ConfigureBucketRoles_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGClouder_ConfigureBucketRoles_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 *MockGClouder_ConfigureBucketRoles_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 *VerifierMockGClouder) ConnectToCluster(_param0 string, _param1 string, _param2 string) *MockGClouder_ConnectToCluster_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ConnectToCluster", params, verifier.timeout)
	return &MockGClouder_ConnectToCluster_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_ConnectToCluster_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_ConnectToCluster_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_ConnectToRegionCluster_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_ConnectToRegionCluster_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_CreateBucket_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CreateBucket_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_CreateDNSZone_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CreateDNSZone_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 *VerifierMockGClouder) CreateGCPServiceAccount(_param0 kubernetes.Interface, _param1 string, _param2 string, _param3 string, _param4 string, _param5 string, _param6 []string, _param7 string) *MockGClouder_CreateGCPServiceAccount_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3, _param4, _param5, _param6, _param7}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateGCPServiceAccount", params, verifier.timeout)
	return &MockGClouder_CreateGCPServiceAccount_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_CreateGCPServiceAccount_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGClouder_CreateGCPServiceAccount_OngoingVerification) GetCapturedArguments() (kubernetes.Interface, string, string, string, string, string, []string, string) {
	_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 *MockGClouder_CreateGCPServiceAccount_OngoingVerification) GetAllCapturedArguments() (_param0 []kubernetes.Interface, _param1 []string, _param2 []string, _param3 []string, _param4 []string, _param5 []string, _param6 [][]string, _param7 []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)
		}
		_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([]string, len(c.methodInvocations))
		for u, param := range params[5] {
			_param5[u] = param.(string)
		}
		_param6 = make([][]string, len(c.methodInvocations))
		for u, param := range params[6] {
			_param6[u] = param.([]string)
		}
		_param7 = make([]string, len(c.methodInvocations))
		for u, param := range params[7] {
			_param7[u] = param.(string)
		}
	}
	return
}

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

type MockGClouder_CreateKmsKey_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CreateKmsKey_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_CreateKmsKeyring_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CreateKmsKeyring_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 *VerifierMockGClouder) CreateManagedZone(_param0 string, _param1 string) *MockGClouder_CreateManagedZone_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateManagedZone", params, verifier.timeout)
	return &MockGClouder_CreateManagedZone_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_CreateManagedZone_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CreateManagedZone_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 *VerifierMockGClouder) CreateServiceAccountKey(_param0 string, _param1 string, _param2 string) *MockGClouder_CreateServiceAccountKey_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "CreateServiceAccountKey", params, verifier.timeout)
	return &MockGClouder_CreateServiceAccountKey_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_CreateServiceAccountKey_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_CreateServiceAccountKey_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_DeleteAllObjectsInBucket_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

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

type MockGClouder_DeleteBucket_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_DeleteBucket_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 *VerifierMockGClouder) DeleteServiceAccount(_param0 string, _param1 string, _param2 []string) *MockGClouder_DeleteServiceAccount_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "DeleteServiceAccount", params, verifier.timeout)
	return &MockGClouder_DeleteServiceAccount_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_DeleteServiceAccount_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_DeleteServiceAccount_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 [][]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)
		}
	}
	return
}

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

type MockGClouder_DeleteServiceAccountKey_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_DeleteServiceAccountKey_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

func (verifier *VerifierMockGClouder) EnableAPIs(_param0 string, _param1 ...string) *MockGClouder_EnableAPIs_OngoingVerification {
	params := []pegomock.Param{_param0}
	for _, param := range _param1 {
		params = append(params, param)
	}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "EnableAPIs", params, verifier.timeout)
	return &MockGClouder_EnableAPIs_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_EnableAPIs_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_EnableAPIs_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 := 0; u < len(c.methodInvocations); u++ {
			_param1[u] = make([]string, len(params)-1)
			for x := 1; x < len(params); x++ {
				if params[x][u] != nil {
					_param1[u][x-1] = params[x][u].(string)
				}
			}
		}
	}
	return
}

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

type MockGClouder_FindBucket_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_FindBucket_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 *VerifierMockGClouder) FindServiceAccount(_param0 string, _param1 string) *MockGClouder_FindServiceAccount_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "FindServiceAccount", params, verifier.timeout)
	return &MockGClouder_FindServiceAccount_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_FindServiceAccount_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

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

type MockGClouder_GetEnabledApis_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_GetEnabledApis_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 *VerifierMockGClouder) GetManagedZoneNameServers(_param0 string, _param1 string) *MockGClouder_GetManagedZoneNameServers_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetManagedZoneNameServers", params, verifier.timeout)
	return &MockGClouder_GetManagedZoneNameServers_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_GetManagedZoneNameServers_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_GetManagedZoneNameServers_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 *VerifierMockGClouder) GetOrCreateServiceAccount(_param0 string, _param1 string, _param2 string, _param3 []string) *MockGClouder_GetOrCreateServiceAccount_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2, _param3}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetOrCreateServiceAccount", params, verifier.timeout)
	return &MockGClouder_GetOrCreateServiceAccount_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_GetOrCreateServiceAccount_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

type MockGClouder_GetProjectNumber_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_GetProjectNumber_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 *VerifierMockGClouder) GetServiceAccountKeys(_param0 string, _param1 string) *MockGClouder_GetServiceAccountKeys_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "GetServiceAccountKeys", params, verifier.timeout)
	return &MockGClouder_GetServiceAccountKeys_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_GetServiceAccountKeys_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_GetServiceAccountKeys_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 *VerifierMockGClouder) IsGCSWriteRoleEnabled(_param0 string, _param1 string) *MockGClouder_IsGCSWriteRoleEnabled_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsGCSWriteRoleEnabled", params, verifier.timeout)
	return &MockGClouder_IsGCSWriteRoleEnabled_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_IsGCSWriteRoleEnabled_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_IsGCSWriteRoleEnabled_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 *VerifierMockGClouder) IsKmsKeyAvailable(_param0 string, _param1 string, _param2 string) *MockGClouder_IsKmsKeyAvailable_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "IsKmsKeyAvailable", params, verifier.timeout)
	return &MockGClouder_IsKmsKeyAvailable_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_IsKmsKeyAvailable_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_IsKmsKeyAvailable_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_IsKmsKeyringAvailable_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_IsKmsKeyringAvailable_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 *VerifierMockGClouder) ListClusters(_param0 string, _param1 string) *MockGClouder_ListClusters_OngoingVerification {
	params := []pegomock.Param{_param0, _param1}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "ListClusters", params, verifier.timeout)
	return &MockGClouder_ListClusters_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_ListClusters_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_ListClusters_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 *VerifierMockGClouder) LoadGkeCluster(_param0 string, _param1 string, _param2 string) *MockGClouder_LoadGkeCluster_OngoingVerification {
	params := []pegomock.Param{_param0, _param1, _param2}
	methodInvocations := pegomock.GetGenericMockFrom(verifier.mock).Verify(verifier.inOrderContext, verifier.invocationCountMatcher, "LoadGkeCluster", params, verifier.timeout)
	return &MockGClouder_LoadGkeCluster_OngoingVerification{mock: verifier.mock, methodInvocations: methodInvocations}
}

type MockGClouder_LoadGkeCluster_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

func (c *MockGClouder_LoadGkeCluster_OngoingVerification) GetAllCapturedArguments() (_param0 []string, _param1 []string, _param2 []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)
		}
	}
	return
}

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

type MockGClouder_Login_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

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

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

type MockGClouder_UpdateGkeClusterLabels_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

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

type MockGClouder_UserLabel_OngoingVerification struct {
	mock              *MockGClouder
	methodInvocations []pegomock.MethodInvocation
}

func (c *MockGClouder_UserLabel_OngoingVerification) GetCapturedArguments() {
}

func (c *MockGClouder_UserLabel_OngoingVerification) GetAllCapturedArguments() {
}