// Code generated by counterfeiter. DO NOT EDIT.
package commandfakes

import (
	"sync"
	"time"

	"code.cloudfoundry.org/cli/command"
	"code.cloudfoundry.org/cli/util/configv3"
)

type FakeConfig struct {
	APIVersionStub        func() string
	aPIVersionMutex       sync.RWMutex
	aPIVersionArgsForCall []struct {
	}
	aPIVersionReturns struct {
		result1 string
	}
	aPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	AccessTokenStub        func() string
	accessTokenMutex       sync.RWMutex
	accessTokenArgsForCall []struct {
	}
	accessTokenReturns struct {
		result1 string
	}
	accessTokenReturnsOnCall map[int]struct {
		result1 string
	}
	AddPluginStub        func(configv3.Plugin)
	addPluginMutex       sync.RWMutex
	addPluginArgsForCall []struct {
		arg1 configv3.Plugin
	}
	AddPluginRepositoryStub        func(string, string)
	addPluginRepositoryMutex       sync.RWMutex
	addPluginRepositoryArgsForCall []struct {
		arg1 string
		arg2 string
	}
	AuthorizationEndpointStub        func() string
	authorizationEndpointMutex       sync.RWMutex
	authorizationEndpointArgsForCall []struct {
	}
	authorizationEndpointReturns struct {
		result1 string
	}
	authorizationEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	B3SpanIDStub        func() string
	b3SpanIDMutex       sync.RWMutex
	b3SpanIDArgsForCall []struct {
	}
	b3SpanIDReturns struct {
		result1 string
	}
	b3SpanIDReturnsOnCall map[int]struct {
		result1 string
	}
	B3TraceIDStub        func() string
	b3TraceIDMutex       sync.RWMutex
	b3TraceIDArgsForCall []struct {
	}
	b3TraceIDReturns struct {
		result1 string
	}
	b3TraceIDReturnsOnCall map[int]struct {
		result1 string
	}
	BinaryNameStub        func() string
	binaryNameMutex       sync.RWMutex
	binaryNameArgsForCall []struct {
	}
	binaryNameReturns struct {
		result1 string
	}
	binaryNameReturnsOnCall map[int]struct {
		result1 string
	}
	BinaryVersionStub        func() string
	binaryVersionMutex       sync.RWMutex
	binaryVersionArgsForCall []struct {
	}
	binaryVersionReturns struct {
		result1 string
	}
	binaryVersionReturnsOnCall map[int]struct {
		result1 string
	}
	CFPasswordStub        func() string
	cFPasswordMutex       sync.RWMutex
	cFPasswordArgsForCall []struct {
	}
	cFPasswordReturns struct {
		result1 string
	}
	cFPasswordReturnsOnCall map[int]struct {
		result1 string
	}
	CFUsernameStub        func() string
	cFUsernameMutex       sync.RWMutex
	cFUsernameArgsForCall []struct {
	}
	cFUsernameReturns struct {
		result1 string
	}
	cFUsernameReturnsOnCall map[int]struct {
		result1 string
	}
	CNBCredentialsStub        func() (map[string]interface{}, error)
	cNBCredentialsMutex       sync.RWMutex
	cNBCredentialsArgsForCall []struct {
	}
	cNBCredentialsReturns struct {
		result1 map[string]interface{}
		result2 error
	}
	cNBCredentialsReturnsOnCall map[int]struct {
		result1 map[string]interface{}
		result2 error
	}
	ColorEnabledStub        func() configv3.ColorSetting
	colorEnabledMutex       sync.RWMutex
	colorEnabledArgsForCall []struct {
	}
	colorEnabledReturns struct {
		result1 configv3.ColorSetting
	}
	colorEnabledReturnsOnCall map[int]struct {
		result1 configv3.ColorSetting
	}
	CurrentUserStub        func() (configv3.User, error)
	currentUserMutex       sync.RWMutex
	currentUserArgsForCall []struct {
	}
	currentUserReturns struct {
		result1 configv3.User
		result2 error
	}
	currentUserReturnsOnCall map[int]struct {
		result1 configv3.User
		result2 error
	}
	CurrentUserNameStub        func() (string, error)
	currentUserNameMutex       sync.RWMutex
	currentUserNameArgsForCall []struct {
	}
	currentUserNameReturns struct {
		result1 string
		result2 error
	}
	currentUserNameReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	DialTimeoutStub        func() time.Duration
	dialTimeoutMutex       sync.RWMutex
	dialTimeoutArgsForCall []struct {
	}
	dialTimeoutReturns struct {
		result1 time.Duration
	}
	dialTimeoutReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	DockerPasswordStub        func() string
	dockerPasswordMutex       sync.RWMutex
	dockerPasswordArgsForCall []struct {
	}
	dockerPasswordReturns struct {
		result1 string
	}
	dockerPasswordReturnsOnCall map[int]struct {
		result1 string
	}
	ExperimentalStub        func() bool
	experimentalMutex       sync.RWMutex
	experimentalArgsForCall []struct {
	}
	experimentalReturns struct {
		result1 bool
	}
	experimentalReturnsOnCall map[int]struct {
		result1 bool
	}
	GetPluginStub        func(string) (configv3.Plugin, bool)
	getPluginMutex       sync.RWMutex
	getPluginArgsForCall []struct {
		arg1 string
	}
	getPluginReturns struct {
		result1 configv3.Plugin
		result2 bool
	}
	getPluginReturnsOnCall map[int]struct {
		result1 configv3.Plugin
		result2 bool
	}
	GetPluginCaseInsensitiveStub        func(string) (configv3.Plugin, bool)
	getPluginCaseInsensitiveMutex       sync.RWMutex
	getPluginCaseInsensitiveArgsForCall []struct {
		arg1 string
	}
	getPluginCaseInsensitiveReturns struct {
		result1 configv3.Plugin
		result2 bool
	}
	getPluginCaseInsensitiveReturnsOnCall map[int]struct {
		result1 configv3.Plugin
		result2 bool
	}
	HasTargetedOrganizationStub        func() bool
	hasTargetedOrganizationMutex       sync.RWMutex
	hasTargetedOrganizationArgsForCall []struct {
	}
	hasTargetedOrganizationReturns struct {
		result1 bool
	}
	hasTargetedOrganizationReturnsOnCall map[int]struct {
		result1 bool
	}
	HasTargetedSpaceStub        func() bool
	hasTargetedSpaceMutex       sync.RWMutex
	hasTargetedSpaceArgsForCall []struct {
	}
	hasTargetedSpaceReturns struct {
		result1 bool
	}
	hasTargetedSpaceReturnsOnCall map[int]struct {
		result1 bool
	}
	IsCFOnK8sStub        func() bool
	isCFOnK8sMutex       sync.RWMutex
	isCFOnK8sArgsForCall []struct {
	}
	isCFOnK8sReturns struct {
		result1 bool
	}
	isCFOnK8sReturnsOnCall map[int]struct {
		result1 bool
	}
	IsTTYStub        func() bool
	isTTYMutex       sync.RWMutex
	isTTYArgsForCall []struct {
	}
	isTTYReturns struct {
		result1 bool
	}
	isTTYReturnsOnCall map[int]struct {
		result1 bool
	}
	LocaleStub        func() string
	localeMutex       sync.RWMutex
	localeArgsForCall []struct {
	}
	localeReturns struct {
		result1 string
	}
	localeReturnsOnCall map[int]struct {
		result1 string
	}
	LogCacheEndpointStub        func() string
	logCacheEndpointMutex       sync.RWMutex
	logCacheEndpointArgsForCall []struct {
	}
	logCacheEndpointReturns struct {
		result1 string
	}
	logCacheEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	MinCLIVersionStub        func() string
	minCLIVersionMutex       sync.RWMutex
	minCLIVersionArgsForCall []struct {
	}
	minCLIVersionReturns struct {
		result1 string
	}
	minCLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	NOAARequestRetryCountStub        func() int
	nOAARequestRetryCountMutex       sync.RWMutex
	nOAARequestRetryCountArgsForCall []struct {
	}
	nOAARequestRetryCountReturns struct {
		result1 int
	}
	nOAARequestRetryCountReturnsOnCall map[int]struct {
		result1 int
	}
	NetworkPolicyV1EndpointStub        func() string
	networkPolicyV1EndpointMutex       sync.RWMutex
	networkPolicyV1EndpointArgsForCall []struct {
	}
	networkPolicyV1EndpointReturns struct {
		result1 string
	}
	networkPolicyV1EndpointReturnsOnCall map[int]struct {
		result1 string
	}
	OverallPollingTimeoutStub        func() time.Duration
	overallPollingTimeoutMutex       sync.RWMutex
	overallPollingTimeoutArgsForCall []struct {
	}
	overallPollingTimeoutReturns struct {
		result1 time.Duration
	}
	overallPollingTimeoutReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	PluginHomeStub        func() string
	pluginHomeMutex       sync.RWMutex
	pluginHomeArgsForCall []struct {
	}
	pluginHomeReturns struct {
		result1 string
	}
	pluginHomeReturnsOnCall map[int]struct {
		result1 string
	}
	PluginRepositoriesStub        func() []configv3.PluginRepository
	pluginRepositoriesMutex       sync.RWMutex
	pluginRepositoriesArgsForCall []struct {
	}
	pluginRepositoriesReturns struct {
		result1 []configv3.PluginRepository
	}
	pluginRepositoriesReturnsOnCall map[int]struct {
		result1 []configv3.PluginRepository
	}
	PluginsStub        func() []configv3.Plugin
	pluginsMutex       sync.RWMutex
	pluginsArgsForCall []struct {
	}
	pluginsReturns struct {
		result1 []configv3.Plugin
	}
	pluginsReturnsOnCall map[int]struct {
		result1 []configv3.Plugin
	}
	PollingIntervalStub        func() time.Duration
	pollingIntervalMutex       sync.RWMutex
	pollingIntervalArgsForCall []struct {
	}
	pollingIntervalReturns struct {
		result1 time.Duration
	}
	pollingIntervalReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	RefreshTokenStub        func() string
	refreshTokenMutex       sync.RWMutex
	refreshTokenArgsForCall []struct {
	}
	refreshTokenReturns struct {
		result1 string
	}
	refreshTokenReturnsOnCall map[int]struct {
		result1 string
	}
	RemovePluginStub        func(string)
	removePluginMutex       sync.RWMutex
	removePluginArgsForCall []struct {
		arg1 string
	}
	RequestRetryCountStub        func() int
	requestRetryCountMutex       sync.RWMutex
	requestRetryCountArgsForCall []struct {
	}
	requestRetryCountReturns struct {
		result1 int
	}
	requestRetryCountReturnsOnCall map[int]struct {
		result1 int
	}
	RoutingEndpointStub        func() string
	routingEndpointMutex       sync.RWMutex
	routingEndpointArgsForCall []struct {
	}
	routingEndpointReturns struct {
		result1 string
	}
	routingEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	SSHOAuthClientStub        func() string
	sSHOAuthClientMutex       sync.RWMutex
	sSHOAuthClientArgsForCall []struct {
	}
	sSHOAuthClientReturns struct {
		result1 string
	}
	sSHOAuthClientReturnsOnCall map[int]struct {
		result1 string
	}
	SetAccessTokenStub        func(string)
	setAccessTokenMutex       sync.RWMutex
	setAccessTokenArgsForCall []struct {
		arg1 string
	}
	SetAsyncTimeoutStub        func(int)
	setAsyncTimeoutMutex       sync.RWMutex
	setAsyncTimeoutArgsForCall []struct {
		arg1 int
	}
	SetColorEnabledStub        func(string)
	setColorEnabledMutex       sync.RWMutex
	setColorEnabledArgsForCall []struct {
		arg1 string
	}
	SetKubernetesAuthInfoStub        func(string)
	setKubernetesAuthInfoMutex       sync.RWMutex
	setKubernetesAuthInfoArgsForCall []struct {
		arg1 string
	}
	SetLocaleStub        func(string)
	setLocaleMutex       sync.RWMutex
	setLocaleArgsForCall []struct {
		arg1 string
	}
	SetMinCLIVersionStub        func(string)
	setMinCLIVersionMutex       sync.RWMutex
	setMinCLIVersionArgsForCall []struct {
		arg1 string
	}
	SetOrganizationInformationStub        func(string, string)
	setOrganizationInformationMutex       sync.RWMutex
	setOrganizationInformationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	SetRefreshTokenStub        func(string)
	setRefreshTokenMutex       sync.RWMutex
	setRefreshTokenArgsForCall []struct {
		arg1 string
	}
	SetSpaceInformationStub        func(string, string, bool)
	setSpaceInformationMutex       sync.RWMutex
	setSpaceInformationArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	SetTargetInformationStub        func(configv3.TargetInformationArgs)
	setTargetInformationMutex       sync.RWMutex
	setTargetInformationArgsForCall []struct {
		arg1 configv3.TargetInformationArgs
	}
	SetTokenInformationStub        func(string, string, string)
	setTokenInformationMutex       sync.RWMutex
	setTokenInformationArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	SetTraceStub        func(string)
	setTraceMutex       sync.RWMutex
	setTraceArgsForCall []struct {
		arg1 string
	}
	SetUAAClientCredentialsStub        func(string, string)
	setUAAClientCredentialsMutex       sync.RWMutex
	setUAAClientCredentialsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	SetUAAEndpointStub        func(string)
	setUAAEndpointMutex       sync.RWMutex
	setUAAEndpointArgsForCall []struct {
		arg1 string
	}
	SetUAAGrantTypeStub        func(string)
	setUAAGrantTypeMutex       sync.RWMutex
	setUAAGrantTypeArgsForCall []struct {
		arg1 string
	}
	SkipSSLValidationStub        func() bool
	skipSSLValidationMutex       sync.RWMutex
	skipSSLValidationArgsForCall []struct {
	}
	skipSSLValidationReturns struct {
		result1 bool
	}
	skipSSLValidationReturnsOnCall map[int]struct {
		result1 bool
	}
	StagingTimeoutStub        func() time.Duration
	stagingTimeoutMutex       sync.RWMutex
	stagingTimeoutArgsForCall []struct {
	}
	stagingTimeoutReturns struct {
		result1 time.Duration
	}
	stagingTimeoutReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	StartupTimeoutStub        func() time.Duration
	startupTimeoutMutex       sync.RWMutex
	startupTimeoutArgsForCall []struct {
	}
	startupTimeoutReturns struct {
		result1 time.Duration
	}
	startupTimeoutReturnsOnCall map[int]struct {
		result1 time.Duration
	}
	TargetStub        func() string
	targetMutex       sync.RWMutex
	targetArgsForCall []struct {
	}
	targetReturns struct {
		result1 string
	}
	targetReturnsOnCall map[int]struct {
		result1 string
	}
	TargetedOrganizationStub        func() configv3.Organization
	targetedOrganizationMutex       sync.RWMutex
	targetedOrganizationArgsForCall []struct {
	}
	targetedOrganizationReturns struct {
		result1 configv3.Organization
	}
	targetedOrganizationReturnsOnCall map[int]struct {
		result1 configv3.Organization
	}
	TargetedOrganizationNameStub        func() string
	targetedOrganizationNameMutex       sync.RWMutex
	targetedOrganizationNameArgsForCall []struct {
	}
	targetedOrganizationNameReturns struct {
		result1 string
	}
	targetedOrganizationNameReturnsOnCall map[int]struct {
		result1 string
	}
	TargetedSpaceStub        func() configv3.Space
	targetedSpaceMutex       sync.RWMutex
	targetedSpaceArgsForCall []struct {
	}
	targetedSpaceReturns struct {
		result1 configv3.Space
	}
	targetedSpaceReturnsOnCall map[int]struct {
		result1 configv3.Space
	}
	TerminalWidthStub        func() int
	terminalWidthMutex       sync.RWMutex
	terminalWidthArgsForCall []struct {
	}
	terminalWidthReturns struct {
		result1 int
	}
	terminalWidthReturnsOnCall map[int]struct {
		result1 int
	}
	UAADisableKeepAlivesStub        func() bool
	uAADisableKeepAlivesMutex       sync.RWMutex
	uAADisableKeepAlivesArgsForCall []struct {
	}
	uAADisableKeepAlivesReturns struct {
		result1 bool
	}
	uAADisableKeepAlivesReturnsOnCall map[int]struct {
		result1 bool
	}
	UAAEndpointStub        func() string
	uAAEndpointMutex       sync.RWMutex
	uAAEndpointArgsForCall []struct {
	}
	uAAEndpointReturns struct {
		result1 string
	}
	uAAEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	UAAGrantTypeStub        func() string
	uAAGrantTypeMutex       sync.RWMutex
	uAAGrantTypeArgsForCall []struct {
	}
	uAAGrantTypeReturns struct {
		result1 string
	}
	uAAGrantTypeReturnsOnCall map[int]struct {
		result1 string
	}
	UAAOAuthClientStub        func() string
	uAAOAuthClientMutex       sync.RWMutex
	uAAOAuthClientArgsForCall []struct {
	}
	uAAOAuthClientReturns struct {
		result1 string
	}
	uAAOAuthClientReturnsOnCall map[int]struct {
		result1 string
	}
	UAAOAuthClientSecretStub        func() string
	uAAOAuthClientSecretMutex       sync.RWMutex
	uAAOAuthClientSecretArgsForCall []struct {
	}
	uAAOAuthClientSecretReturns struct {
		result1 string
	}
	uAAOAuthClientSecretReturnsOnCall map[int]struct {
		result1 string
	}
	UnsetOrganizationAndSpaceInformationStub        func()
	unsetOrganizationAndSpaceInformationMutex       sync.RWMutex
	unsetOrganizationAndSpaceInformationArgsForCall []struct {
	}
	UnsetSpaceInformationStub        func()
	unsetSpaceInformationMutex       sync.RWMutex
	unsetSpaceInformationArgsForCall []struct {
	}
	UnsetUserInformationStub        func()
	unsetUserInformationMutex       sync.RWMutex
	unsetUserInformationArgsForCall []struct {
	}
	V7SetSpaceInformationStub        func(string, string)
	v7SetSpaceInformationMutex       sync.RWMutex
	v7SetSpaceInformationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	VerboseStub        func() (bool, []string)
	verboseMutex       sync.RWMutex
	verboseArgsForCall []struct {
	}
	verboseReturns struct {
		result1 bool
		result2 []string
	}
	verboseReturnsOnCall map[int]struct {
		result1 bool
		result2 []string
	}
	WriteConfigStub        func() error
	writeConfigMutex       sync.RWMutex
	writeConfigArgsForCall []struct {
	}
	writeConfigReturns struct {
		result1 error
	}
	writeConfigReturnsOnCall map[int]struct {
		result1 error
	}
	WritePluginConfigStub        func() error
	writePluginConfigMutex       sync.RWMutex
	writePluginConfigArgsForCall []struct {
	}
	writePluginConfigReturns struct {
		result1 error
	}
	writePluginConfigReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeConfig) APIVersion() string {
	fake.aPIVersionMutex.Lock()
	ret, specificReturn := fake.aPIVersionReturnsOnCall[len(fake.aPIVersionArgsForCall)]
	fake.aPIVersionArgsForCall = append(fake.aPIVersionArgsForCall, struct {
	}{})
	stub := fake.APIVersionStub
	fakeReturns := fake.aPIVersionReturns
	fake.recordInvocation("APIVersion", []interface{}{})
	fake.aPIVersionMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) APIVersionCallCount() int {
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	return len(fake.aPIVersionArgsForCall)
}

func (fake *FakeConfig) APIVersionCalls(stub func() string) {
	fake.aPIVersionMutex.Lock()
	defer fake.aPIVersionMutex.Unlock()
	fake.APIVersionStub = stub
}

func (fake *FakeConfig) APIVersionReturns(result1 string) {
	fake.aPIVersionMutex.Lock()
	defer fake.aPIVersionMutex.Unlock()
	fake.APIVersionStub = nil
	fake.aPIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) APIVersionReturnsOnCall(i int, result1 string) {
	fake.aPIVersionMutex.Lock()
	defer fake.aPIVersionMutex.Unlock()
	fake.APIVersionStub = nil
	if fake.aPIVersionReturnsOnCall == nil {
		fake.aPIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.aPIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) AccessToken() string {
	fake.accessTokenMutex.Lock()
	ret, specificReturn := fake.accessTokenReturnsOnCall[len(fake.accessTokenArgsForCall)]
	fake.accessTokenArgsForCall = append(fake.accessTokenArgsForCall, struct {
	}{})
	stub := fake.AccessTokenStub
	fakeReturns := fake.accessTokenReturns
	fake.recordInvocation("AccessToken", []interface{}{})
	fake.accessTokenMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) AccessTokenCallCount() int {
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	return len(fake.accessTokenArgsForCall)
}

func (fake *FakeConfig) AccessTokenCalls(stub func() string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = stub
}

func (fake *FakeConfig) AccessTokenReturns(result1 string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = nil
	fake.accessTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) AccessTokenReturnsOnCall(i int, result1 string) {
	fake.accessTokenMutex.Lock()
	defer fake.accessTokenMutex.Unlock()
	fake.AccessTokenStub = nil
	if fake.accessTokenReturnsOnCall == nil {
		fake.accessTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.accessTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) AddPlugin(arg1 configv3.Plugin) {
	fake.addPluginMutex.Lock()
	fake.addPluginArgsForCall = append(fake.addPluginArgsForCall, struct {
		arg1 configv3.Plugin
	}{arg1})
	stub := fake.AddPluginStub
	fake.recordInvocation("AddPlugin", []interface{}{arg1})
	fake.addPluginMutex.Unlock()
	if stub != nil {
		fake.AddPluginStub(arg1)
	}
}

func (fake *FakeConfig) AddPluginCallCount() int {
	fake.addPluginMutex.RLock()
	defer fake.addPluginMutex.RUnlock()
	return len(fake.addPluginArgsForCall)
}

func (fake *FakeConfig) AddPluginCalls(stub func(configv3.Plugin)) {
	fake.addPluginMutex.Lock()
	defer fake.addPluginMutex.Unlock()
	fake.AddPluginStub = stub
}

func (fake *FakeConfig) AddPluginArgsForCall(i int) configv3.Plugin {
	fake.addPluginMutex.RLock()
	defer fake.addPluginMutex.RUnlock()
	argsForCall := fake.addPluginArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) AddPluginRepository(arg1 string, arg2 string) {
	fake.addPluginRepositoryMutex.Lock()
	fake.addPluginRepositoryArgsForCall = append(fake.addPluginRepositoryArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.AddPluginRepositoryStub
	fake.recordInvocation("AddPluginRepository", []interface{}{arg1, arg2})
	fake.addPluginRepositoryMutex.Unlock()
	if stub != nil {
		fake.AddPluginRepositoryStub(arg1, arg2)
	}
}

func (fake *FakeConfig) AddPluginRepositoryCallCount() int {
	fake.addPluginRepositoryMutex.RLock()
	defer fake.addPluginRepositoryMutex.RUnlock()
	return len(fake.addPluginRepositoryArgsForCall)
}

func (fake *FakeConfig) AddPluginRepositoryCalls(stub func(string, string)) {
	fake.addPluginRepositoryMutex.Lock()
	defer fake.addPluginRepositoryMutex.Unlock()
	fake.AddPluginRepositoryStub = stub
}

func (fake *FakeConfig) AddPluginRepositoryArgsForCall(i int) (string, string) {
	fake.addPluginRepositoryMutex.RLock()
	defer fake.addPluginRepositoryMutex.RUnlock()
	argsForCall := fake.addPluginRepositoryArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeConfig) AuthorizationEndpoint() string {
	fake.authorizationEndpointMutex.Lock()
	ret, specificReturn := fake.authorizationEndpointReturnsOnCall[len(fake.authorizationEndpointArgsForCall)]
	fake.authorizationEndpointArgsForCall = append(fake.authorizationEndpointArgsForCall, struct {
	}{})
	stub := fake.AuthorizationEndpointStub
	fakeReturns := fake.authorizationEndpointReturns
	fake.recordInvocation("AuthorizationEndpoint", []interface{}{})
	fake.authorizationEndpointMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) AuthorizationEndpointCallCount() int {
	fake.authorizationEndpointMutex.RLock()
	defer fake.authorizationEndpointMutex.RUnlock()
	return len(fake.authorizationEndpointArgsForCall)
}

func (fake *FakeConfig) AuthorizationEndpointCalls(stub func() string) {
	fake.authorizationEndpointMutex.Lock()
	defer fake.authorizationEndpointMutex.Unlock()
	fake.AuthorizationEndpointStub = stub
}

func (fake *FakeConfig) AuthorizationEndpointReturns(result1 string) {
	fake.authorizationEndpointMutex.Lock()
	defer fake.authorizationEndpointMutex.Unlock()
	fake.AuthorizationEndpointStub = nil
	fake.authorizationEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) AuthorizationEndpointReturnsOnCall(i int, result1 string) {
	fake.authorizationEndpointMutex.Lock()
	defer fake.authorizationEndpointMutex.Unlock()
	fake.AuthorizationEndpointStub = nil
	if fake.authorizationEndpointReturnsOnCall == nil {
		fake.authorizationEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.authorizationEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) B3SpanID() string {
	fake.b3SpanIDMutex.Lock()
	ret, specificReturn := fake.b3SpanIDReturnsOnCall[len(fake.b3SpanIDArgsForCall)]
	fake.b3SpanIDArgsForCall = append(fake.b3SpanIDArgsForCall, struct {
	}{})
	stub := fake.B3SpanIDStub
	fakeReturns := fake.b3SpanIDReturns
	fake.recordInvocation("B3SpanID", []interface{}{})
	fake.b3SpanIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) B3SpanIDCallCount() int {
	fake.b3SpanIDMutex.RLock()
	defer fake.b3SpanIDMutex.RUnlock()
	return len(fake.b3SpanIDArgsForCall)
}

func (fake *FakeConfig) B3SpanIDCalls(stub func() string) {
	fake.b3SpanIDMutex.Lock()
	defer fake.b3SpanIDMutex.Unlock()
	fake.B3SpanIDStub = stub
}

func (fake *FakeConfig) B3SpanIDReturns(result1 string) {
	fake.b3SpanIDMutex.Lock()
	defer fake.b3SpanIDMutex.Unlock()
	fake.B3SpanIDStub = nil
	fake.b3SpanIDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) B3SpanIDReturnsOnCall(i int, result1 string) {
	fake.b3SpanIDMutex.Lock()
	defer fake.b3SpanIDMutex.Unlock()
	fake.B3SpanIDStub = nil
	if fake.b3SpanIDReturnsOnCall == nil {
		fake.b3SpanIDReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.b3SpanIDReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) B3TraceID() string {
	fake.b3TraceIDMutex.Lock()
	ret, specificReturn := fake.b3TraceIDReturnsOnCall[len(fake.b3TraceIDArgsForCall)]
	fake.b3TraceIDArgsForCall = append(fake.b3TraceIDArgsForCall, struct {
	}{})
	stub := fake.B3TraceIDStub
	fakeReturns := fake.b3TraceIDReturns
	fake.recordInvocation("B3TraceID", []interface{}{})
	fake.b3TraceIDMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) B3TraceIDCallCount() int {
	fake.b3TraceIDMutex.RLock()
	defer fake.b3TraceIDMutex.RUnlock()
	return len(fake.b3TraceIDArgsForCall)
}

func (fake *FakeConfig) B3TraceIDCalls(stub func() string) {
	fake.b3TraceIDMutex.Lock()
	defer fake.b3TraceIDMutex.Unlock()
	fake.B3TraceIDStub = stub
}

func (fake *FakeConfig) B3TraceIDReturns(result1 string) {
	fake.b3TraceIDMutex.Lock()
	defer fake.b3TraceIDMutex.Unlock()
	fake.B3TraceIDStub = nil
	fake.b3TraceIDReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) B3TraceIDReturnsOnCall(i int, result1 string) {
	fake.b3TraceIDMutex.Lock()
	defer fake.b3TraceIDMutex.Unlock()
	fake.B3TraceIDStub = nil
	if fake.b3TraceIDReturnsOnCall == nil {
		fake.b3TraceIDReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.b3TraceIDReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) BinaryName() string {
	fake.binaryNameMutex.Lock()
	ret, specificReturn := fake.binaryNameReturnsOnCall[len(fake.binaryNameArgsForCall)]
	fake.binaryNameArgsForCall = append(fake.binaryNameArgsForCall, struct {
	}{})
	stub := fake.BinaryNameStub
	fakeReturns := fake.binaryNameReturns
	fake.recordInvocation("BinaryName", []interface{}{})
	fake.binaryNameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) BinaryNameCallCount() int {
	fake.binaryNameMutex.RLock()
	defer fake.binaryNameMutex.RUnlock()
	return len(fake.binaryNameArgsForCall)
}

func (fake *FakeConfig) BinaryNameCalls(stub func() string) {
	fake.binaryNameMutex.Lock()
	defer fake.binaryNameMutex.Unlock()
	fake.BinaryNameStub = stub
}

func (fake *FakeConfig) BinaryNameReturns(result1 string) {
	fake.binaryNameMutex.Lock()
	defer fake.binaryNameMutex.Unlock()
	fake.BinaryNameStub = nil
	fake.binaryNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) BinaryNameReturnsOnCall(i int, result1 string) {
	fake.binaryNameMutex.Lock()
	defer fake.binaryNameMutex.Unlock()
	fake.BinaryNameStub = nil
	if fake.binaryNameReturnsOnCall == nil {
		fake.binaryNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.binaryNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) BinaryVersion() string {
	fake.binaryVersionMutex.Lock()
	ret, specificReturn := fake.binaryVersionReturnsOnCall[len(fake.binaryVersionArgsForCall)]
	fake.binaryVersionArgsForCall = append(fake.binaryVersionArgsForCall, struct {
	}{})
	stub := fake.BinaryVersionStub
	fakeReturns := fake.binaryVersionReturns
	fake.recordInvocation("BinaryVersion", []interface{}{})
	fake.binaryVersionMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) BinaryVersionCallCount() int {
	fake.binaryVersionMutex.RLock()
	defer fake.binaryVersionMutex.RUnlock()
	return len(fake.binaryVersionArgsForCall)
}

func (fake *FakeConfig) BinaryVersionCalls(stub func() string) {
	fake.binaryVersionMutex.Lock()
	defer fake.binaryVersionMutex.Unlock()
	fake.BinaryVersionStub = stub
}

func (fake *FakeConfig) BinaryVersionReturns(result1 string) {
	fake.binaryVersionMutex.Lock()
	defer fake.binaryVersionMutex.Unlock()
	fake.BinaryVersionStub = nil
	fake.binaryVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) BinaryVersionReturnsOnCall(i int, result1 string) {
	fake.binaryVersionMutex.Lock()
	defer fake.binaryVersionMutex.Unlock()
	fake.BinaryVersionStub = nil
	if fake.binaryVersionReturnsOnCall == nil {
		fake.binaryVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.binaryVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) CFPassword() string {
	fake.cFPasswordMutex.Lock()
	ret, specificReturn := fake.cFPasswordReturnsOnCall[len(fake.cFPasswordArgsForCall)]
	fake.cFPasswordArgsForCall = append(fake.cFPasswordArgsForCall, struct {
	}{})
	stub := fake.CFPasswordStub
	fakeReturns := fake.cFPasswordReturns
	fake.recordInvocation("CFPassword", []interface{}{})
	fake.cFPasswordMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) CFPasswordCallCount() int {
	fake.cFPasswordMutex.RLock()
	defer fake.cFPasswordMutex.RUnlock()
	return len(fake.cFPasswordArgsForCall)
}

func (fake *FakeConfig) CFPasswordCalls(stub func() string) {
	fake.cFPasswordMutex.Lock()
	defer fake.cFPasswordMutex.Unlock()
	fake.CFPasswordStub = stub
}

func (fake *FakeConfig) CFPasswordReturns(result1 string) {
	fake.cFPasswordMutex.Lock()
	defer fake.cFPasswordMutex.Unlock()
	fake.CFPasswordStub = nil
	fake.cFPasswordReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) CFPasswordReturnsOnCall(i int, result1 string) {
	fake.cFPasswordMutex.Lock()
	defer fake.cFPasswordMutex.Unlock()
	fake.CFPasswordStub = nil
	if fake.cFPasswordReturnsOnCall == nil {
		fake.cFPasswordReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.cFPasswordReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) CFUsername() string {
	fake.cFUsernameMutex.Lock()
	ret, specificReturn := fake.cFUsernameReturnsOnCall[len(fake.cFUsernameArgsForCall)]
	fake.cFUsernameArgsForCall = append(fake.cFUsernameArgsForCall, struct {
	}{})
	stub := fake.CFUsernameStub
	fakeReturns := fake.cFUsernameReturns
	fake.recordInvocation("CFUsername", []interface{}{})
	fake.cFUsernameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) CFUsernameCallCount() int {
	fake.cFUsernameMutex.RLock()
	defer fake.cFUsernameMutex.RUnlock()
	return len(fake.cFUsernameArgsForCall)
}

func (fake *FakeConfig) CFUsernameCalls(stub func() string) {
	fake.cFUsernameMutex.Lock()
	defer fake.cFUsernameMutex.Unlock()
	fake.CFUsernameStub = stub
}

func (fake *FakeConfig) CFUsernameReturns(result1 string) {
	fake.cFUsernameMutex.Lock()
	defer fake.cFUsernameMutex.Unlock()
	fake.CFUsernameStub = nil
	fake.cFUsernameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) CFUsernameReturnsOnCall(i int, result1 string) {
	fake.cFUsernameMutex.Lock()
	defer fake.cFUsernameMutex.Unlock()
	fake.CFUsernameStub = nil
	if fake.cFUsernameReturnsOnCall == nil {
		fake.cFUsernameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.cFUsernameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) CNBCredentials() (map[string]interface{}, error) {
	fake.cNBCredentialsMutex.Lock()
	ret, specificReturn := fake.cNBCredentialsReturnsOnCall[len(fake.cNBCredentialsArgsForCall)]
	fake.cNBCredentialsArgsForCall = append(fake.cNBCredentialsArgsForCall, struct {
	}{})
	stub := fake.CNBCredentialsStub
	fakeReturns := fake.cNBCredentialsReturns
	fake.recordInvocation("CNBCredentials", []interface{}{})
	fake.cNBCredentialsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) CNBCredentialsCallCount() int {
	fake.cNBCredentialsMutex.RLock()
	defer fake.cNBCredentialsMutex.RUnlock()
	return len(fake.cNBCredentialsArgsForCall)
}

func (fake *FakeConfig) CNBCredentialsCalls(stub func() (map[string]interface{}, error)) {
	fake.cNBCredentialsMutex.Lock()
	defer fake.cNBCredentialsMutex.Unlock()
	fake.CNBCredentialsStub = stub
}

func (fake *FakeConfig) CNBCredentialsReturns(result1 map[string]interface{}, result2 error) {
	fake.cNBCredentialsMutex.Lock()
	defer fake.cNBCredentialsMutex.Unlock()
	fake.CNBCredentialsStub = nil
	fake.cNBCredentialsReturns = struct {
		result1 map[string]interface{}
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) CNBCredentialsReturnsOnCall(i int, result1 map[string]interface{}, result2 error) {
	fake.cNBCredentialsMutex.Lock()
	defer fake.cNBCredentialsMutex.Unlock()
	fake.CNBCredentialsStub = nil
	if fake.cNBCredentialsReturnsOnCall == nil {
		fake.cNBCredentialsReturnsOnCall = make(map[int]struct {
			result1 map[string]interface{}
			result2 error
		})
	}
	fake.cNBCredentialsReturnsOnCall[i] = struct {
		result1 map[string]interface{}
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) ColorEnabled() configv3.ColorSetting {
	fake.colorEnabledMutex.Lock()
	ret, specificReturn := fake.colorEnabledReturnsOnCall[len(fake.colorEnabledArgsForCall)]
	fake.colorEnabledArgsForCall = append(fake.colorEnabledArgsForCall, struct {
	}{})
	stub := fake.ColorEnabledStub
	fakeReturns := fake.colorEnabledReturns
	fake.recordInvocation("ColorEnabled", []interface{}{})
	fake.colorEnabledMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) ColorEnabledCallCount() int {
	fake.colorEnabledMutex.RLock()
	defer fake.colorEnabledMutex.RUnlock()
	return len(fake.colorEnabledArgsForCall)
}

func (fake *FakeConfig) ColorEnabledCalls(stub func() configv3.ColorSetting) {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.ColorEnabledStub = stub
}

func (fake *FakeConfig) ColorEnabledReturns(result1 configv3.ColorSetting) {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.ColorEnabledStub = nil
	fake.colorEnabledReturns = struct {
		result1 configv3.ColorSetting
	}{result1}
}

func (fake *FakeConfig) ColorEnabledReturnsOnCall(i int, result1 configv3.ColorSetting) {
	fake.colorEnabledMutex.Lock()
	defer fake.colorEnabledMutex.Unlock()
	fake.ColorEnabledStub = nil
	if fake.colorEnabledReturnsOnCall == nil {
		fake.colorEnabledReturnsOnCall = make(map[int]struct {
			result1 configv3.ColorSetting
		})
	}
	fake.colorEnabledReturnsOnCall[i] = struct {
		result1 configv3.ColorSetting
	}{result1}
}

func (fake *FakeConfig) CurrentUser() (configv3.User, error) {
	fake.currentUserMutex.Lock()
	ret, specificReturn := fake.currentUserReturnsOnCall[len(fake.currentUserArgsForCall)]
	fake.currentUserArgsForCall = append(fake.currentUserArgsForCall, struct {
	}{})
	stub := fake.CurrentUserStub
	fakeReturns := fake.currentUserReturns
	fake.recordInvocation("CurrentUser", []interface{}{})
	fake.currentUserMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) CurrentUserCallCount() int {
	fake.currentUserMutex.RLock()
	defer fake.currentUserMutex.RUnlock()
	return len(fake.currentUserArgsForCall)
}

func (fake *FakeConfig) CurrentUserCalls(stub func() (configv3.User, error)) {
	fake.currentUserMutex.Lock()
	defer fake.currentUserMutex.Unlock()
	fake.CurrentUserStub = stub
}

func (fake *FakeConfig) CurrentUserReturns(result1 configv3.User, result2 error) {
	fake.currentUserMutex.Lock()
	defer fake.currentUserMutex.Unlock()
	fake.CurrentUserStub = nil
	fake.currentUserReturns = struct {
		result1 configv3.User
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) CurrentUserReturnsOnCall(i int, result1 configv3.User, result2 error) {
	fake.currentUserMutex.Lock()
	defer fake.currentUserMutex.Unlock()
	fake.CurrentUserStub = nil
	if fake.currentUserReturnsOnCall == nil {
		fake.currentUserReturnsOnCall = make(map[int]struct {
			result1 configv3.User
			result2 error
		})
	}
	fake.currentUserReturnsOnCall[i] = struct {
		result1 configv3.User
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) CurrentUserName() (string, error) {
	fake.currentUserNameMutex.Lock()
	ret, specificReturn := fake.currentUserNameReturnsOnCall[len(fake.currentUserNameArgsForCall)]
	fake.currentUserNameArgsForCall = append(fake.currentUserNameArgsForCall, struct {
	}{})
	stub := fake.CurrentUserNameStub
	fakeReturns := fake.currentUserNameReturns
	fake.recordInvocation("CurrentUserName", []interface{}{})
	fake.currentUserNameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) CurrentUserNameCallCount() int {
	fake.currentUserNameMutex.RLock()
	defer fake.currentUserNameMutex.RUnlock()
	return len(fake.currentUserNameArgsForCall)
}

func (fake *FakeConfig) CurrentUserNameCalls(stub func() (string, error)) {
	fake.currentUserNameMutex.Lock()
	defer fake.currentUserNameMutex.Unlock()
	fake.CurrentUserNameStub = stub
}

func (fake *FakeConfig) CurrentUserNameReturns(result1 string, result2 error) {
	fake.currentUserNameMutex.Lock()
	defer fake.currentUserNameMutex.Unlock()
	fake.CurrentUserNameStub = nil
	fake.currentUserNameReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) CurrentUserNameReturnsOnCall(i int, result1 string, result2 error) {
	fake.currentUserNameMutex.Lock()
	defer fake.currentUserNameMutex.Unlock()
	fake.CurrentUserNameStub = nil
	if fake.currentUserNameReturnsOnCall == nil {
		fake.currentUserNameReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.currentUserNameReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeConfig) DialTimeout() time.Duration {
	fake.dialTimeoutMutex.Lock()
	ret, specificReturn := fake.dialTimeoutReturnsOnCall[len(fake.dialTimeoutArgsForCall)]
	fake.dialTimeoutArgsForCall = append(fake.dialTimeoutArgsForCall, struct {
	}{})
	stub := fake.DialTimeoutStub
	fakeReturns := fake.dialTimeoutReturns
	fake.recordInvocation("DialTimeout", []interface{}{})
	fake.dialTimeoutMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) DialTimeoutCallCount() int {
	fake.dialTimeoutMutex.RLock()
	defer fake.dialTimeoutMutex.RUnlock()
	return len(fake.dialTimeoutArgsForCall)
}

func (fake *FakeConfig) DialTimeoutCalls(stub func() time.Duration) {
	fake.dialTimeoutMutex.Lock()
	defer fake.dialTimeoutMutex.Unlock()
	fake.DialTimeoutStub = stub
}

func (fake *FakeConfig) DialTimeoutReturns(result1 time.Duration) {
	fake.dialTimeoutMutex.Lock()
	defer fake.dialTimeoutMutex.Unlock()
	fake.DialTimeoutStub = nil
	fake.dialTimeoutReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) DialTimeoutReturnsOnCall(i int, result1 time.Duration) {
	fake.dialTimeoutMutex.Lock()
	defer fake.dialTimeoutMutex.Unlock()
	fake.DialTimeoutStub = nil
	if fake.dialTimeoutReturnsOnCall == nil {
		fake.dialTimeoutReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.dialTimeoutReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) DockerPassword() string {
	fake.dockerPasswordMutex.Lock()
	ret, specificReturn := fake.dockerPasswordReturnsOnCall[len(fake.dockerPasswordArgsForCall)]
	fake.dockerPasswordArgsForCall = append(fake.dockerPasswordArgsForCall, struct {
	}{})
	stub := fake.DockerPasswordStub
	fakeReturns := fake.dockerPasswordReturns
	fake.recordInvocation("DockerPassword", []interface{}{})
	fake.dockerPasswordMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) DockerPasswordCallCount() int {
	fake.dockerPasswordMutex.RLock()
	defer fake.dockerPasswordMutex.RUnlock()
	return len(fake.dockerPasswordArgsForCall)
}

func (fake *FakeConfig) DockerPasswordCalls(stub func() string) {
	fake.dockerPasswordMutex.Lock()
	defer fake.dockerPasswordMutex.Unlock()
	fake.DockerPasswordStub = stub
}

func (fake *FakeConfig) DockerPasswordReturns(result1 string) {
	fake.dockerPasswordMutex.Lock()
	defer fake.dockerPasswordMutex.Unlock()
	fake.DockerPasswordStub = nil
	fake.dockerPasswordReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) DockerPasswordReturnsOnCall(i int, result1 string) {
	fake.dockerPasswordMutex.Lock()
	defer fake.dockerPasswordMutex.Unlock()
	fake.DockerPasswordStub = nil
	if fake.dockerPasswordReturnsOnCall == nil {
		fake.dockerPasswordReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.dockerPasswordReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) Experimental() bool {
	fake.experimentalMutex.Lock()
	ret, specificReturn := fake.experimentalReturnsOnCall[len(fake.experimentalArgsForCall)]
	fake.experimentalArgsForCall = append(fake.experimentalArgsForCall, struct {
	}{})
	stub := fake.ExperimentalStub
	fakeReturns := fake.experimentalReturns
	fake.recordInvocation("Experimental", []interface{}{})
	fake.experimentalMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) ExperimentalCallCount() int {
	fake.experimentalMutex.RLock()
	defer fake.experimentalMutex.RUnlock()
	return len(fake.experimentalArgsForCall)
}

func (fake *FakeConfig) ExperimentalCalls(stub func() bool) {
	fake.experimentalMutex.Lock()
	defer fake.experimentalMutex.Unlock()
	fake.ExperimentalStub = stub
}

func (fake *FakeConfig) ExperimentalReturns(result1 bool) {
	fake.experimentalMutex.Lock()
	defer fake.experimentalMutex.Unlock()
	fake.ExperimentalStub = nil
	fake.experimentalReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) ExperimentalReturnsOnCall(i int, result1 bool) {
	fake.experimentalMutex.Lock()
	defer fake.experimentalMutex.Unlock()
	fake.ExperimentalStub = nil
	if fake.experimentalReturnsOnCall == nil {
		fake.experimentalReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.experimentalReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) GetPlugin(arg1 string) (configv3.Plugin, bool) {
	fake.getPluginMutex.Lock()
	ret, specificReturn := fake.getPluginReturnsOnCall[len(fake.getPluginArgsForCall)]
	fake.getPluginArgsForCall = append(fake.getPluginArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetPluginStub
	fakeReturns := fake.getPluginReturns
	fake.recordInvocation("GetPlugin", []interface{}{arg1})
	fake.getPluginMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) GetPluginCallCount() int {
	fake.getPluginMutex.RLock()
	defer fake.getPluginMutex.RUnlock()
	return len(fake.getPluginArgsForCall)
}

func (fake *FakeConfig) GetPluginCalls(stub func(string) (configv3.Plugin, bool)) {
	fake.getPluginMutex.Lock()
	defer fake.getPluginMutex.Unlock()
	fake.GetPluginStub = stub
}

func (fake *FakeConfig) GetPluginArgsForCall(i int) string {
	fake.getPluginMutex.RLock()
	defer fake.getPluginMutex.RUnlock()
	argsForCall := fake.getPluginArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) GetPluginReturns(result1 configv3.Plugin, result2 bool) {
	fake.getPluginMutex.Lock()
	defer fake.getPluginMutex.Unlock()
	fake.GetPluginStub = nil
	fake.getPluginReturns = struct {
		result1 configv3.Plugin
		result2 bool
	}{result1, result2}
}

func (fake *FakeConfig) GetPluginReturnsOnCall(i int, result1 configv3.Plugin, result2 bool) {
	fake.getPluginMutex.Lock()
	defer fake.getPluginMutex.Unlock()
	fake.GetPluginStub = nil
	if fake.getPluginReturnsOnCall == nil {
		fake.getPluginReturnsOnCall = make(map[int]struct {
			result1 configv3.Plugin
			result2 bool
		})
	}
	fake.getPluginReturnsOnCall[i] = struct {
		result1 configv3.Plugin
		result2 bool
	}{result1, result2}
}

func (fake *FakeConfig) GetPluginCaseInsensitive(arg1 string) (configv3.Plugin, bool) {
	fake.getPluginCaseInsensitiveMutex.Lock()
	ret, specificReturn := fake.getPluginCaseInsensitiveReturnsOnCall[len(fake.getPluginCaseInsensitiveArgsForCall)]
	fake.getPluginCaseInsensitiveArgsForCall = append(fake.getPluginCaseInsensitiveArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetPluginCaseInsensitiveStub
	fakeReturns := fake.getPluginCaseInsensitiveReturns
	fake.recordInvocation("GetPluginCaseInsensitive", []interface{}{arg1})
	fake.getPluginCaseInsensitiveMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) GetPluginCaseInsensitiveCallCount() int {
	fake.getPluginCaseInsensitiveMutex.RLock()
	defer fake.getPluginCaseInsensitiveMutex.RUnlock()
	return len(fake.getPluginCaseInsensitiveArgsForCall)
}

func (fake *FakeConfig) GetPluginCaseInsensitiveCalls(stub func(string) (configv3.Plugin, bool)) {
	fake.getPluginCaseInsensitiveMutex.Lock()
	defer fake.getPluginCaseInsensitiveMutex.Unlock()
	fake.GetPluginCaseInsensitiveStub = stub
}

func (fake *FakeConfig) GetPluginCaseInsensitiveArgsForCall(i int) string {
	fake.getPluginCaseInsensitiveMutex.RLock()
	defer fake.getPluginCaseInsensitiveMutex.RUnlock()
	argsForCall := fake.getPluginCaseInsensitiveArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) GetPluginCaseInsensitiveReturns(result1 configv3.Plugin, result2 bool) {
	fake.getPluginCaseInsensitiveMutex.Lock()
	defer fake.getPluginCaseInsensitiveMutex.Unlock()
	fake.GetPluginCaseInsensitiveStub = nil
	fake.getPluginCaseInsensitiveReturns = struct {
		result1 configv3.Plugin
		result2 bool
	}{result1, result2}
}

func (fake *FakeConfig) GetPluginCaseInsensitiveReturnsOnCall(i int, result1 configv3.Plugin, result2 bool) {
	fake.getPluginCaseInsensitiveMutex.Lock()
	defer fake.getPluginCaseInsensitiveMutex.Unlock()
	fake.GetPluginCaseInsensitiveStub = nil
	if fake.getPluginCaseInsensitiveReturnsOnCall == nil {
		fake.getPluginCaseInsensitiveReturnsOnCall = make(map[int]struct {
			result1 configv3.Plugin
			result2 bool
		})
	}
	fake.getPluginCaseInsensitiveReturnsOnCall[i] = struct {
		result1 configv3.Plugin
		result2 bool
	}{result1, result2}
}

func (fake *FakeConfig) HasTargetedOrganization() bool {
	fake.hasTargetedOrganizationMutex.Lock()
	ret, specificReturn := fake.hasTargetedOrganizationReturnsOnCall[len(fake.hasTargetedOrganizationArgsForCall)]
	fake.hasTargetedOrganizationArgsForCall = append(fake.hasTargetedOrganizationArgsForCall, struct {
	}{})
	stub := fake.HasTargetedOrganizationStub
	fakeReturns := fake.hasTargetedOrganizationReturns
	fake.recordInvocation("HasTargetedOrganization", []interface{}{})
	fake.hasTargetedOrganizationMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) HasTargetedOrganizationCallCount() int {
	fake.hasTargetedOrganizationMutex.RLock()
	defer fake.hasTargetedOrganizationMutex.RUnlock()
	return len(fake.hasTargetedOrganizationArgsForCall)
}

func (fake *FakeConfig) HasTargetedOrganizationCalls(stub func() bool) {
	fake.hasTargetedOrganizationMutex.Lock()
	defer fake.hasTargetedOrganizationMutex.Unlock()
	fake.HasTargetedOrganizationStub = stub
}

func (fake *FakeConfig) HasTargetedOrganizationReturns(result1 bool) {
	fake.hasTargetedOrganizationMutex.Lock()
	defer fake.hasTargetedOrganizationMutex.Unlock()
	fake.HasTargetedOrganizationStub = nil
	fake.hasTargetedOrganizationReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) HasTargetedOrganizationReturnsOnCall(i int, result1 bool) {
	fake.hasTargetedOrganizationMutex.Lock()
	defer fake.hasTargetedOrganizationMutex.Unlock()
	fake.HasTargetedOrganizationStub = nil
	if fake.hasTargetedOrganizationReturnsOnCall == nil {
		fake.hasTargetedOrganizationReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasTargetedOrganizationReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) HasTargetedSpace() bool {
	fake.hasTargetedSpaceMutex.Lock()
	ret, specificReturn := fake.hasTargetedSpaceReturnsOnCall[len(fake.hasTargetedSpaceArgsForCall)]
	fake.hasTargetedSpaceArgsForCall = append(fake.hasTargetedSpaceArgsForCall, struct {
	}{})
	stub := fake.HasTargetedSpaceStub
	fakeReturns := fake.hasTargetedSpaceReturns
	fake.recordInvocation("HasTargetedSpace", []interface{}{})
	fake.hasTargetedSpaceMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) HasTargetedSpaceCallCount() int {
	fake.hasTargetedSpaceMutex.RLock()
	defer fake.hasTargetedSpaceMutex.RUnlock()
	return len(fake.hasTargetedSpaceArgsForCall)
}

func (fake *FakeConfig) HasTargetedSpaceCalls(stub func() bool) {
	fake.hasTargetedSpaceMutex.Lock()
	defer fake.hasTargetedSpaceMutex.Unlock()
	fake.HasTargetedSpaceStub = stub
}

func (fake *FakeConfig) HasTargetedSpaceReturns(result1 bool) {
	fake.hasTargetedSpaceMutex.Lock()
	defer fake.hasTargetedSpaceMutex.Unlock()
	fake.HasTargetedSpaceStub = nil
	fake.hasTargetedSpaceReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) HasTargetedSpaceReturnsOnCall(i int, result1 bool) {
	fake.hasTargetedSpaceMutex.Lock()
	defer fake.hasTargetedSpaceMutex.Unlock()
	fake.HasTargetedSpaceStub = nil
	if fake.hasTargetedSpaceReturnsOnCall == nil {
		fake.hasTargetedSpaceReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.hasTargetedSpaceReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) IsCFOnK8s() bool {
	fake.isCFOnK8sMutex.Lock()
	ret, specificReturn := fake.isCFOnK8sReturnsOnCall[len(fake.isCFOnK8sArgsForCall)]
	fake.isCFOnK8sArgsForCall = append(fake.isCFOnK8sArgsForCall, struct {
	}{})
	stub := fake.IsCFOnK8sStub
	fakeReturns := fake.isCFOnK8sReturns
	fake.recordInvocation("IsCFOnK8s", []interface{}{})
	fake.isCFOnK8sMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) IsCFOnK8sCallCount() int {
	fake.isCFOnK8sMutex.RLock()
	defer fake.isCFOnK8sMutex.RUnlock()
	return len(fake.isCFOnK8sArgsForCall)
}

func (fake *FakeConfig) IsCFOnK8sCalls(stub func() bool) {
	fake.isCFOnK8sMutex.Lock()
	defer fake.isCFOnK8sMutex.Unlock()
	fake.IsCFOnK8sStub = stub
}

func (fake *FakeConfig) IsCFOnK8sReturns(result1 bool) {
	fake.isCFOnK8sMutex.Lock()
	defer fake.isCFOnK8sMutex.Unlock()
	fake.IsCFOnK8sStub = nil
	fake.isCFOnK8sReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) IsCFOnK8sReturnsOnCall(i int, result1 bool) {
	fake.isCFOnK8sMutex.Lock()
	defer fake.isCFOnK8sMutex.Unlock()
	fake.IsCFOnK8sStub = nil
	if fake.isCFOnK8sReturnsOnCall == nil {
		fake.isCFOnK8sReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isCFOnK8sReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) IsTTY() bool {
	fake.isTTYMutex.Lock()
	ret, specificReturn := fake.isTTYReturnsOnCall[len(fake.isTTYArgsForCall)]
	fake.isTTYArgsForCall = append(fake.isTTYArgsForCall, struct {
	}{})
	stub := fake.IsTTYStub
	fakeReturns := fake.isTTYReturns
	fake.recordInvocation("IsTTY", []interface{}{})
	fake.isTTYMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) IsTTYCallCount() int {
	fake.isTTYMutex.RLock()
	defer fake.isTTYMutex.RUnlock()
	return len(fake.isTTYArgsForCall)
}

func (fake *FakeConfig) IsTTYCalls(stub func() bool) {
	fake.isTTYMutex.Lock()
	defer fake.isTTYMutex.Unlock()
	fake.IsTTYStub = stub
}

func (fake *FakeConfig) IsTTYReturns(result1 bool) {
	fake.isTTYMutex.Lock()
	defer fake.isTTYMutex.Unlock()
	fake.IsTTYStub = nil
	fake.isTTYReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) IsTTYReturnsOnCall(i int, result1 bool) {
	fake.isTTYMutex.Lock()
	defer fake.isTTYMutex.Unlock()
	fake.IsTTYStub = nil
	if fake.isTTYReturnsOnCall == nil {
		fake.isTTYReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.isTTYReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) Locale() string {
	fake.localeMutex.Lock()
	ret, specificReturn := fake.localeReturnsOnCall[len(fake.localeArgsForCall)]
	fake.localeArgsForCall = append(fake.localeArgsForCall, struct {
	}{})
	stub := fake.LocaleStub
	fakeReturns := fake.localeReturns
	fake.recordInvocation("Locale", []interface{}{})
	fake.localeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) LocaleCallCount() int {
	fake.localeMutex.RLock()
	defer fake.localeMutex.RUnlock()
	return len(fake.localeArgsForCall)
}

func (fake *FakeConfig) LocaleCalls(stub func() string) {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.LocaleStub = stub
}

func (fake *FakeConfig) LocaleReturns(result1 string) {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.LocaleStub = nil
	fake.localeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) LocaleReturnsOnCall(i int, result1 string) {
	fake.localeMutex.Lock()
	defer fake.localeMutex.Unlock()
	fake.LocaleStub = nil
	if fake.localeReturnsOnCall == nil {
		fake.localeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.localeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) LogCacheEndpoint() string {
	fake.logCacheEndpointMutex.Lock()
	ret, specificReturn := fake.logCacheEndpointReturnsOnCall[len(fake.logCacheEndpointArgsForCall)]
	fake.logCacheEndpointArgsForCall = append(fake.logCacheEndpointArgsForCall, struct {
	}{})
	stub := fake.LogCacheEndpointStub
	fakeReturns := fake.logCacheEndpointReturns
	fake.recordInvocation("LogCacheEndpoint", []interface{}{})
	fake.logCacheEndpointMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) LogCacheEndpointCallCount() int {
	fake.logCacheEndpointMutex.RLock()
	defer fake.logCacheEndpointMutex.RUnlock()
	return len(fake.logCacheEndpointArgsForCall)
}

func (fake *FakeConfig) LogCacheEndpointCalls(stub func() string) {
	fake.logCacheEndpointMutex.Lock()
	defer fake.logCacheEndpointMutex.Unlock()
	fake.LogCacheEndpointStub = stub
}

func (fake *FakeConfig) LogCacheEndpointReturns(result1 string) {
	fake.logCacheEndpointMutex.Lock()
	defer fake.logCacheEndpointMutex.Unlock()
	fake.LogCacheEndpointStub = nil
	fake.logCacheEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) LogCacheEndpointReturnsOnCall(i int, result1 string) {
	fake.logCacheEndpointMutex.Lock()
	defer fake.logCacheEndpointMutex.Unlock()
	fake.LogCacheEndpointStub = nil
	if fake.logCacheEndpointReturnsOnCall == nil {
		fake.logCacheEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.logCacheEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) MinCLIVersion() string {
	fake.minCLIVersionMutex.Lock()
	ret, specificReturn := fake.minCLIVersionReturnsOnCall[len(fake.minCLIVersionArgsForCall)]
	fake.minCLIVersionArgsForCall = append(fake.minCLIVersionArgsForCall, struct {
	}{})
	stub := fake.MinCLIVersionStub
	fakeReturns := fake.minCLIVersionReturns
	fake.recordInvocation("MinCLIVersion", []interface{}{})
	fake.minCLIVersionMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) MinCLIVersionCallCount() int {
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	return len(fake.minCLIVersionArgsForCall)
}

func (fake *FakeConfig) MinCLIVersionCalls(stub func() string) {
	fake.minCLIVersionMutex.Lock()
	defer fake.minCLIVersionMutex.Unlock()
	fake.MinCLIVersionStub = stub
}

func (fake *FakeConfig) MinCLIVersionReturns(result1 string) {
	fake.minCLIVersionMutex.Lock()
	defer fake.minCLIVersionMutex.Unlock()
	fake.MinCLIVersionStub = nil
	fake.minCLIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) MinCLIVersionReturnsOnCall(i int, result1 string) {
	fake.minCLIVersionMutex.Lock()
	defer fake.minCLIVersionMutex.Unlock()
	fake.MinCLIVersionStub = nil
	if fake.minCLIVersionReturnsOnCall == nil {
		fake.minCLIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.minCLIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) NOAARequestRetryCount() int {
	fake.nOAARequestRetryCountMutex.Lock()
	ret, specificReturn := fake.nOAARequestRetryCountReturnsOnCall[len(fake.nOAARequestRetryCountArgsForCall)]
	fake.nOAARequestRetryCountArgsForCall = append(fake.nOAARequestRetryCountArgsForCall, struct {
	}{})
	stub := fake.NOAARequestRetryCountStub
	fakeReturns := fake.nOAARequestRetryCountReturns
	fake.recordInvocation("NOAARequestRetryCount", []interface{}{})
	fake.nOAARequestRetryCountMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) NOAARequestRetryCountCallCount() int {
	fake.nOAARequestRetryCountMutex.RLock()
	defer fake.nOAARequestRetryCountMutex.RUnlock()
	return len(fake.nOAARequestRetryCountArgsForCall)
}

func (fake *FakeConfig) NOAARequestRetryCountCalls(stub func() int) {
	fake.nOAARequestRetryCountMutex.Lock()
	defer fake.nOAARequestRetryCountMutex.Unlock()
	fake.NOAARequestRetryCountStub = stub
}

func (fake *FakeConfig) NOAARequestRetryCountReturns(result1 int) {
	fake.nOAARequestRetryCountMutex.Lock()
	defer fake.nOAARequestRetryCountMutex.Unlock()
	fake.NOAARequestRetryCountStub = nil
	fake.nOAARequestRetryCountReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeConfig) NOAARequestRetryCountReturnsOnCall(i int, result1 int) {
	fake.nOAARequestRetryCountMutex.Lock()
	defer fake.nOAARequestRetryCountMutex.Unlock()
	fake.NOAARequestRetryCountStub = nil
	if fake.nOAARequestRetryCountReturnsOnCall == nil {
		fake.nOAARequestRetryCountReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.nOAARequestRetryCountReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeConfig) NetworkPolicyV1Endpoint() string {
	fake.networkPolicyV1EndpointMutex.Lock()
	ret, specificReturn := fake.networkPolicyV1EndpointReturnsOnCall[len(fake.networkPolicyV1EndpointArgsForCall)]
	fake.networkPolicyV1EndpointArgsForCall = append(fake.networkPolicyV1EndpointArgsForCall, struct {
	}{})
	stub := fake.NetworkPolicyV1EndpointStub
	fakeReturns := fake.networkPolicyV1EndpointReturns
	fake.recordInvocation("NetworkPolicyV1Endpoint", []interface{}{})
	fake.networkPolicyV1EndpointMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) NetworkPolicyV1EndpointCallCount() int {
	fake.networkPolicyV1EndpointMutex.RLock()
	defer fake.networkPolicyV1EndpointMutex.RUnlock()
	return len(fake.networkPolicyV1EndpointArgsForCall)
}

func (fake *FakeConfig) NetworkPolicyV1EndpointCalls(stub func() string) {
	fake.networkPolicyV1EndpointMutex.Lock()
	defer fake.networkPolicyV1EndpointMutex.Unlock()
	fake.NetworkPolicyV1EndpointStub = stub
}

func (fake *FakeConfig) NetworkPolicyV1EndpointReturns(result1 string) {
	fake.networkPolicyV1EndpointMutex.Lock()
	defer fake.networkPolicyV1EndpointMutex.Unlock()
	fake.NetworkPolicyV1EndpointStub = nil
	fake.networkPolicyV1EndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) NetworkPolicyV1EndpointReturnsOnCall(i int, result1 string) {
	fake.networkPolicyV1EndpointMutex.Lock()
	defer fake.networkPolicyV1EndpointMutex.Unlock()
	fake.NetworkPolicyV1EndpointStub = nil
	if fake.networkPolicyV1EndpointReturnsOnCall == nil {
		fake.networkPolicyV1EndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.networkPolicyV1EndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) OverallPollingTimeout() time.Duration {
	fake.overallPollingTimeoutMutex.Lock()
	ret, specificReturn := fake.overallPollingTimeoutReturnsOnCall[len(fake.overallPollingTimeoutArgsForCall)]
	fake.overallPollingTimeoutArgsForCall = append(fake.overallPollingTimeoutArgsForCall, struct {
	}{})
	stub := fake.OverallPollingTimeoutStub
	fakeReturns := fake.overallPollingTimeoutReturns
	fake.recordInvocation("OverallPollingTimeout", []interface{}{})
	fake.overallPollingTimeoutMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) OverallPollingTimeoutCallCount() int {
	fake.overallPollingTimeoutMutex.RLock()
	defer fake.overallPollingTimeoutMutex.RUnlock()
	return len(fake.overallPollingTimeoutArgsForCall)
}

func (fake *FakeConfig) OverallPollingTimeoutCalls(stub func() time.Duration) {
	fake.overallPollingTimeoutMutex.Lock()
	defer fake.overallPollingTimeoutMutex.Unlock()
	fake.OverallPollingTimeoutStub = stub
}

func (fake *FakeConfig) OverallPollingTimeoutReturns(result1 time.Duration) {
	fake.overallPollingTimeoutMutex.Lock()
	defer fake.overallPollingTimeoutMutex.Unlock()
	fake.OverallPollingTimeoutStub = nil
	fake.overallPollingTimeoutReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) OverallPollingTimeoutReturnsOnCall(i int, result1 time.Duration) {
	fake.overallPollingTimeoutMutex.Lock()
	defer fake.overallPollingTimeoutMutex.Unlock()
	fake.OverallPollingTimeoutStub = nil
	if fake.overallPollingTimeoutReturnsOnCall == nil {
		fake.overallPollingTimeoutReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.overallPollingTimeoutReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) PluginHome() string {
	fake.pluginHomeMutex.Lock()
	ret, specificReturn := fake.pluginHomeReturnsOnCall[len(fake.pluginHomeArgsForCall)]
	fake.pluginHomeArgsForCall = append(fake.pluginHomeArgsForCall, struct {
	}{})
	stub := fake.PluginHomeStub
	fakeReturns := fake.pluginHomeReturns
	fake.recordInvocation("PluginHome", []interface{}{})
	fake.pluginHomeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) PluginHomeCallCount() int {
	fake.pluginHomeMutex.RLock()
	defer fake.pluginHomeMutex.RUnlock()
	return len(fake.pluginHomeArgsForCall)
}

func (fake *FakeConfig) PluginHomeCalls(stub func() string) {
	fake.pluginHomeMutex.Lock()
	defer fake.pluginHomeMutex.Unlock()
	fake.PluginHomeStub = stub
}

func (fake *FakeConfig) PluginHomeReturns(result1 string) {
	fake.pluginHomeMutex.Lock()
	defer fake.pluginHomeMutex.Unlock()
	fake.PluginHomeStub = nil
	fake.pluginHomeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) PluginHomeReturnsOnCall(i int, result1 string) {
	fake.pluginHomeMutex.Lock()
	defer fake.pluginHomeMutex.Unlock()
	fake.PluginHomeStub = nil
	if fake.pluginHomeReturnsOnCall == nil {
		fake.pluginHomeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.pluginHomeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) PluginRepositories() []configv3.PluginRepository {
	fake.pluginRepositoriesMutex.Lock()
	ret, specificReturn := fake.pluginRepositoriesReturnsOnCall[len(fake.pluginRepositoriesArgsForCall)]
	fake.pluginRepositoriesArgsForCall = append(fake.pluginRepositoriesArgsForCall, struct {
	}{})
	stub := fake.PluginRepositoriesStub
	fakeReturns := fake.pluginRepositoriesReturns
	fake.recordInvocation("PluginRepositories", []interface{}{})
	fake.pluginRepositoriesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) PluginRepositoriesCallCount() int {
	fake.pluginRepositoriesMutex.RLock()
	defer fake.pluginRepositoriesMutex.RUnlock()
	return len(fake.pluginRepositoriesArgsForCall)
}

func (fake *FakeConfig) PluginRepositoriesCalls(stub func() []configv3.PluginRepository) {
	fake.pluginRepositoriesMutex.Lock()
	defer fake.pluginRepositoriesMutex.Unlock()
	fake.PluginRepositoriesStub = stub
}

func (fake *FakeConfig) PluginRepositoriesReturns(result1 []configv3.PluginRepository) {
	fake.pluginRepositoriesMutex.Lock()
	defer fake.pluginRepositoriesMutex.Unlock()
	fake.PluginRepositoriesStub = nil
	fake.pluginRepositoriesReturns = struct {
		result1 []configv3.PluginRepository
	}{result1}
}

func (fake *FakeConfig) PluginRepositoriesReturnsOnCall(i int, result1 []configv3.PluginRepository) {
	fake.pluginRepositoriesMutex.Lock()
	defer fake.pluginRepositoriesMutex.Unlock()
	fake.PluginRepositoriesStub = nil
	if fake.pluginRepositoriesReturnsOnCall == nil {
		fake.pluginRepositoriesReturnsOnCall = make(map[int]struct {
			result1 []configv3.PluginRepository
		})
	}
	fake.pluginRepositoriesReturnsOnCall[i] = struct {
		result1 []configv3.PluginRepository
	}{result1}
}

func (fake *FakeConfig) Plugins() []configv3.Plugin {
	fake.pluginsMutex.Lock()
	ret, specificReturn := fake.pluginsReturnsOnCall[len(fake.pluginsArgsForCall)]
	fake.pluginsArgsForCall = append(fake.pluginsArgsForCall, struct {
	}{})
	stub := fake.PluginsStub
	fakeReturns := fake.pluginsReturns
	fake.recordInvocation("Plugins", []interface{}{})
	fake.pluginsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) PluginsCallCount() int {
	fake.pluginsMutex.RLock()
	defer fake.pluginsMutex.RUnlock()
	return len(fake.pluginsArgsForCall)
}

func (fake *FakeConfig) PluginsCalls(stub func() []configv3.Plugin) {
	fake.pluginsMutex.Lock()
	defer fake.pluginsMutex.Unlock()
	fake.PluginsStub = stub
}

func (fake *FakeConfig) PluginsReturns(result1 []configv3.Plugin) {
	fake.pluginsMutex.Lock()
	defer fake.pluginsMutex.Unlock()
	fake.PluginsStub = nil
	fake.pluginsReturns = struct {
		result1 []configv3.Plugin
	}{result1}
}

func (fake *FakeConfig) PluginsReturnsOnCall(i int, result1 []configv3.Plugin) {
	fake.pluginsMutex.Lock()
	defer fake.pluginsMutex.Unlock()
	fake.PluginsStub = nil
	if fake.pluginsReturnsOnCall == nil {
		fake.pluginsReturnsOnCall = make(map[int]struct {
			result1 []configv3.Plugin
		})
	}
	fake.pluginsReturnsOnCall[i] = struct {
		result1 []configv3.Plugin
	}{result1}
}

func (fake *FakeConfig) PollingInterval() time.Duration {
	fake.pollingIntervalMutex.Lock()
	ret, specificReturn := fake.pollingIntervalReturnsOnCall[len(fake.pollingIntervalArgsForCall)]
	fake.pollingIntervalArgsForCall = append(fake.pollingIntervalArgsForCall, struct {
	}{})
	stub := fake.PollingIntervalStub
	fakeReturns := fake.pollingIntervalReturns
	fake.recordInvocation("PollingInterval", []interface{}{})
	fake.pollingIntervalMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) PollingIntervalCallCount() int {
	fake.pollingIntervalMutex.RLock()
	defer fake.pollingIntervalMutex.RUnlock()
	return len(fake.pollingIntervalArgsForCall)
}

func (fake *FakeConfig) PollingIntervalCalls(stub func() time.Duration) {
	fake.pollingIntervalMutex.Lock()
	defer fake.pollingIntervalMutex.Unlock()
	fake.PollingIntervalStub = stub
}

func (fake *FakeConfig) PollingIntervalReturns(result1 time.Duration) {
	fake.pollingIntervalMutex.Lock()
	defer fake.pollingIntervalMutex.Unlock()
	fake.PollingIntervalStub = nil
	fake.pollingIntervalReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) PollingIntervalReturnsOnCall(i int, result1 time.Duration) {
	fake.pollingIntervalMutex.Lock()
	defer fake.pollingIntervalMutex.Unlock()
	fake.PollingIntervalStub = nil
	if fake.pollingIntervalReturnsOnCall == nil {
		fake.pollingIntervalReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.pollingIntervalReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) RefreshToken() string {
	fake.refreshTokenMutex.Lock()
	ret, specificReturn := fake.refreshTokenReturnsOnCall[len(fake.refreshTokenArgsForCall)]
	fake.refreshTokenArgsForCall = append(fake.refreshTokenArgsForCall, struct {
	}{})
	stub := fake.RefreshTokenStub
	fakeReturns := fake.refreshTokenReturns
	fake.recordInvocation("RefreshToken", []interface{}{})
	fake.refreshTokenMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) RefreshTokenCallCount() int {
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	return len(fake.refreshTokenArgsForCall)
}

func (fake *FakeConfig) RefreshTokenCalls(stub func() string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = stub
}

func (fake *FakeConfig) RefreshTokenReturns(result1 string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = nil
	fake.refreshTokenReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) RefreshTokenReturnsOnCall(i int, result1 string) {
	fake.refreshTokenMutex.Lock()
	defer fake.refreshTokenMutex.Unlock()
	fake.RefreshTokenStub = nil
	if fake.refreshTokenReturnsOnCall == nil {
		fake.refreshTokenReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.refreshTokenReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) RemovePlugin(arg1 string) {
	fake.removePluginMutex.Lock()
	fake.removePluginArgsForCall = append(fake.removePluginArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RemovePluginStub
	fake.recordInvocation("RemovePlugin", []interface{}{arg1})
	fake.removePluginMutex.Unlock()
	if stub != nil {
		fake.RemovePluginStub(arg1)
	}
}

func (fake *FakeConfig) RemovePluginCallCount() int {
	fake.removePluginMutex.RLock()
	defer fake.removePluginMutex.RUnlock()
	return len(fake.removePluginArgsForCall)
}

func (fake *FakeConfig) RemovePluginCalls(stub func(string)) {
	fake.removePluginMutex.Lock()
	defer fake.removePluginMutex.Unlock()
	fake.RemovePluginStub = stub
}

func (fake *FakeConfig) RemovePluginArgsForCall(i int) string {
	fake.removePluginMutex.RLock()
	defer fake.removePluginMutex.RUnlock()
	argsForCall := fake.removePluginArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) RequestRetryCount() int {
	fake.requestRetryCountMutex.Lock()
	ret, specificReturn := fake.requestRetryCountReturnsOnCall[len(fake.requestRetryCountArgsForCall)]
	fake.requestRetryCountArgsForCall = append(fake.requestRetryCountArgsForCall, struct {
	}{})
	stub := fake.RequestRetryCountStub
	fakeReturns := fake.requestRetryCountReturns
	fake.recordInvocation("RequestRetryCount", []interface{}{})
	fake.requestRetryCountMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) RequestRetryCountCallCount() int {
	fake.requestRetryCountMutex.RLock()
	defer fake.requestRetryCountMutex.RUnlock()
	return len(fake.requestRetryCountArgsForCall)
}

func (fake *FakeConfig) RequestRetryCountCalls(stub func() int) {
	fake.requestRetryCountMutex.Lock()
	defer fake.requestRetryCountMutex.Unlock()
	fake.RequestRetryCountStub = stub
}

func (fake *FakeConfig) RequestRetryCountReturns(result1 int) {
	fake.requestRetryCountMutex.Lock()
	defer fake.requestRetryCountMutex.Unlock()
	fake.RequestRetryCountStub = nil
	fake.requestRetryCountReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeConfig) RequestRetryCountReturnsOnCall(i int, result1 int) {
	fake.requestRetryCountMutex.Lock()
	defer fake.requestRetryCountMutex.Unlock()
	fake.RequestRetryCountStub = nil
	if fake.requestRetryCountReturnsOnCall == nil {
		fake.requestRetryCountReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.requestRetryCountReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeConfig) RoutingEndpoint() string {
	fake.routingEndpointMutex.Lock()
	ret, specificReturn := fake.routingEndpointReturnsOnCall[len(fake.routingEndpointArgsForCall)]
	fake.routingEndpointArgsForCall = append(fake.routingEndpointArgsForCall, struct {
	}{})
	stub := fake.RoutingEndpointStub
	fakeReturns := fake.routingEndpointReturns
	fake.recordInvocation("RoutingEndpoint", []interface{}{})
	fake.routingEndpointMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) RoutingEndpointCallCount() int {
	fake.routingEndpointMutex.RLock()
	defer fake.routingEndpointMutex.RUnlock()
	return len(fake.routingEndpointArgsForCall)
}

func (fake *FakeConfig) RoutingEndpointCalls(stub func() string) {
	fake.routingEndpointMutex.Lock()
	defer fake.routingEndpointMutex.Unlock()
	fake.RoutingEndpointStub = stub
}

func (fake *FakeConfig) RoutingEndpointReturns(result1 string) {
	fake.routingEndpointMutex.Lock()
	defer fake.routingEndpointMutex.Unlock()
	fake.RoutingEndpointStub = nil
	fake.routingEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) RoutingEndpointReturnsOnCall(i int, result1 string) {
	fake.routingEndpointMutex.Lock()
	defer fake.routingEndpointMutex.Unlock()
	fake.RoutingEndpointStub = nil
	if fake.routingEndpointReturnsOnCall == nil {
		fake.routingEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.routingEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) SSHOAuthClient() string {
	fake.sSHOAuthClientMutex.Lock()
	ret, specificReturn := fake.sSHOAuthClientReturnsOnCall[len(fake.sSHOAuthClientArgsForCall)]
	fake.sSHOAuthClientArgsForCall = append(fake.sSHOAuthClientArgsForCall, struct {
	}{})
	stub := fake.SSHOAuthClientStub
	fakeReturns := fake.sSHOAuthClientReturns
	fake.recordInvocation("SSHOAuthClient", []interface{}{})
	fake.sSHOAuthClientMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) SSHOAuthClientCallCount() int {
	fake.sSHOAuthClientMutex.RLock()
	defer fake.sSHOAuthClientMutex.RUnlock()
	return len(fake.sSHOAuthClientArgsForCall)
}

func (fake *FakeConfig) SSHOAuthClientCalls(stub func() string) {
	fake.sSHOAuthClientMutex.Lock()
	defer fake.sSHOAuthClientMutex.Unlock()
	fake.SSHOAuthClientStub = stub
}

func (fake *FakeConfig) SSHOAuthClientReturns(result1 string) {
	fake.sSHOAuthClientMutex.Lock()
	defer fake.sSHOAuthClientMutex.Unlock()
	fake.SSHOAuthClientStub = nil
	fake.sSHOAuthClientReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) SSHOAuthClientReturnsOnCall(i int, result1 string) {
	fake.sSHOAuthClientMutex.Lock()
	defer fake.sSHOAuthClientMutex.Unlock()
	fake.SSHOAuthClientStub = nil
	if fake.sSHOAuthClientReturnsOnCall == nil {
		fake.sSHOAuthClientReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.sSHOAuthClientReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) SetAccessToken(arg1 string) {
	fake.setAccessTokenMutex.Lock()
	fake.setAccessTokenArgsForCall = append(fake.setAccessTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetAccessTokenStub
	fake.recordInvocation("SetAccessToken", []interface{}{arg1})
	fake.setAccessTokenMutex.Unlock()
	if stub != nil {
		fake.SetAccessTokenStub(arg1)
	}
}

func (fake *FakeConfig) SetAccessTokenCallCount() int {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	return len(fake.setAccessTokenArgsForCall)
}

func (fake *FakeConfig) SetAccessTokenCalls(stub func(string)) {
	fake.setAccessTokenMutex.Lock()
	defer fake.setAccessTokenMutex.Unlock()
	fake.SetAccessTokenStub = stub
}

func (fake *FakeConfig) SetAccessTokenArgsForCall(i int) string {
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	argsForCall := fake.setAccessTokenArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetAsyncTimeout(arg1 int) {
	fake.setAsyncTimeoutMutex.Lock()
	fake.setAsyncTimeoutArgsForCall = append(fake.setAsyncTimeoutArgsForCall, struct {
		arg1 int
	}{arg1})
	stub := fake.SetAsyncTimeoutStub
	fake.recordInvocation("SetAsyncTimeout", []interface{}{arg1})
	fake.setAsyncTimeoutMutex.Unlock()
	if stub != nil {
		fake.SetAsyncTimeoutStub(arg1)
	}
}

func (fake *FakeConfig) SetAsyncTimeoutCallCount() int {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	return len(fake.setAsyncTimeoutArgsForCall)
}

func (fake *FakeConfig) SetAsyncTimeoutCalls(stub func(int)) {
	fake.setAsyncTimeoutMutex.Lock()
	defer fake.setAsyncTimeoutMutex.Unlock()
	fake.SetAsyncTimeoutStub = stub
}

func (fake *FakeConfig) SetAsyncTimeoutArgsForCall(i int) int {
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	argsForCall := fake.setAsyncTimeoutArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetColorEnabled(arg1 string) {
	fake.setColorEnabledMutex.Lock()
	fake.setColorEnabledArgsForCall = append(fake.setColorEnabledArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetColorEnabledStub
	fake.recordInvocation("SetColorEnabled", []interface{}{arg1})
	fake.setColorEnabledMutex.Unlock()
	if stub != nil {
		fake.SetColorEnabledStub(arg1)
	}
}

func (fake *FakeConfig) SetColorEnabledCallCount() int {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	return len(fake.setColorEnabledArgsForCall)
}

func (fake *FakeConfig) SetColorEnabledCalls(stub func(string)) {
	fake.setColorEnabledMutex.Lock()
	defer fake.setColorEnabledMutex.Unlock()
	fake.SetColorEnabledStub = stub
}

func (fake *FakeConfig) SetColorEnabledArgsForCall(i int) string {
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	argsForCall := fake.setColorEnabledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetKubernetesAuthInfo(arg1 string) {
	fake.setKubernetesAuthInfoMutex.Lock()
	fake.setKubernetesAuthInfoArgsForCall = append(fake.setKubernetesAuthInfoArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetKubernetesAuthInfoStub
	fake.recordInvocation("SetKubernetesAuthInfo", []interface{}{arg1})
	fake.setKubernetesAuthInfoMutex.Unlock()
	if stub != nil {
		fake.SetKubernetesAuthInfoStub(arg1)
	}
}

func (fake *FakeConfig) SetKubernetesAuthInfoCallCount() int {
	fake.setKubernetesAuthInfoMutex.RLock()
	defer fake.setKubernetesAuthInfoMutex.RUnlock()
	return len(fake.setKubernetesAuthInfoArgsForCall)
}

func (fake *FakeConfig) SetKubernetesAuthInfoCalls(stub func(string)) {
	fake.setKubernetesAuthInfoMutex.Lock()
	defer fake.setKubernetesAuthInfoMutex.Unlock()
	fake.SetKubernetesAuthInfoStub = stub
}

func (fake *FakeConfig) SetKubernetesAuthInfoArgsForCall(i int) string {
	fake.setKubernetesAuthInfoMutex.RLock()
	defer fake.setKubernetesAuthInfoMutex.RUnlock()
	argsForCall := fake.setKubernetesAuthInfoArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetLocale(arg1 string) {
	fake.setLocaleMutex.Lock()
	fake.setLocaleArgsForCall = append(fake.setLocaleArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetLocaleStub
	fake.recordInvocation("SetLocale", []interface{}{arg1})
	fake.setLocaleMutex.Unlock()
	if stub != nil {
		fake.SetLocaleStub(arg1)
	}
}

func (fake *FakeConfig) SetLocaleCallCount() int {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	return len(fake.setLocaleArgsForCall)
}

func (fake *FakeConfig) SetLocaleCalls(stub func(string)) {
	fake.setLocaleMutex.Lock()
	defer fake.setLocaleMutex.Unlock()
	fake.SetLocaleStub = stub
}

func (fake *FakeConfig) SetLocaleArgsForCall(i int) string {
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	argsForCall := fake.setLocaleArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetMinCLIVersion(arg1 string) {
	fake.setMinCLIVersionMutex.Lock()
	fake.setMinCLIVersionArgsForCall = append(fake.setMinCLIVersionArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetMinCLIVersionStub
	fake.recordInvocation("SetMinCLIVersion", []interface{}{arg1})
	fake.setMinCLIVersionMutex.Unlock()
	if stub != nil {
		fake.SetMinCLIVersionStub(arg1)
	}
}

func (fake *FakeConfig) SetMinCLIVersionCallCount() int {
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	return len(fake.setMinCLIVersionArgsForCall)
}

func (fake *FakeConfig) SetMinCLIVersionCalls(stub func(string)) {
	fake.setMinCLIVersionMutex.Lock()
	defer fake.setMinCLIVersionMutex.Unlock()
	fake.SetMinCLIVersionStub = stub
}

func (fake *FakeConfig) SetMinCLIVersionArgsForCall(i int) string {
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	argsForCall := fake.setMinCLIVersionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetOrganizationInformation(arg1 string, arg2 string) {
	fake.setOrganizationInformationMutex.Lock()
	fake.setOrganizationInformationArgsForCall = append(fake.setOrganizationInformationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.SetOrganizationInformationStub
	fake.recordInvocation("SetOrganizationInformation", []interface{}{arg1, arg2})
	fake.setOrganizationInformationMutex.Unlock()
	if stub != nil {
		fake.SetOrganizationInformationStub(arg1, arg2)
	}
}

func (fake *FakeConfig) SetOrganizationInformationCallCount() int {
	fake.setOrganizationInformationMutex.RLock()
	defer fake.setOrganizationInformationMutex.RUnlock()
	return len(fake.setOrganizationInformationArgsForCall)
}

func (fake *FakeConfig) SetOrganizationInformationCalls(stub func(string, string)) {
	fake.setOrganizationInformationMutex.Lock()
	defer fake.setOrganizationInformationMutex.Unlock()
	fake.SetOrganizationInformationStub = stub
}

func (fake *FakeConfig) SetOrganizationInformationArgsForCall(i int) (string, string) {
	fake.setOrganizationInformationMutex.RLock()
	defer fake.setOrganizationInformationMutex.RUnlock()
	argsForCall := fake.setOrganizationInformationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeConfig) SetRefreshToken(arg1 string) {
	fake.setRefreshTokenMutex.Lock()
	fake.setRefreshTokenArgsForCall = append(fake.setRefreshTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetRefreshTokenStub
	fake.recordInvocation("SetRefreshToken", []interface{}{arg1})
	fake.setRefreshTokenMutex.Unlock()
	if stub != nil {
		fake.SetRefreshTokenStub(arg1)
	}
}

func (fake *FakeConfig) SetRefreshTokenCallCount() int {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	return len(fake.setRefreshTokenArgsForCall)
}

func (fake *FakeConfig) SetRefreshTokenCalls(stub func(string)) {
	fake.setRefreshTokenMutex.Lock()
	defer fake.setRefreshTokenMutex.Unlock()
	fake.SetRefreshTokenStub = stub
}

func (fake *FakeConfig) SetRefreshTokenArgsForCall(i int) string {
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	argsForCall := fake.setRefreshTokenArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetSpaceInformation(arg1 string, arg2 string, arg3 bool) {
	fake.setSpaceInformationMutex.Lock()
	fake.setSpaceInformationArgsForCall = append(fake.setSpaceInformationArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	stub := fake.SetSpaceInformationStub
	fake.recordInvocation("SetSpaceInformation", []interface{}{arg1, arg2, arg3})
	fake.setSpaceInformationMutex.Unlock()
	if stub != nil {
		fake.SetSpaceInformationStub(arg1, arg2, arg3)
	}
}

func (fake *FakeConfig) SetSpaceInformationCallCount() int {
	fake.setSpaceInformationMutex.RLock()
	defer fake.setSpaceInformationMutex.RUnlock()
	return len(fake.setSpaceInformationArgsForCall)
}

func (fake *FakeConfig) SetSpaceInformationCalls(stub func(string, string, bool)) {
	fake.setSpaceInformationMutex.Lock()
	defer fake.setSpaceInformationMutex.Unlock()
	fake.SetSpaceInformationStub = stub
}

func (fake *FakeConfig) SetSpaceInformationArgsForCall(i int) (string, string, bool) {
	fake.setSpaceInformationMutex.RLock()
	defer fake.setSpaceInformationMutex.RUnlock()
	argsForCall := fake.setSpaceInformationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeConfig) SetTargetInformation(arg1 configv3.TargetInformationArgs) {
	fake.setTargetInformationMutex.Lock()
	fake.setTargetInformationArgsForCall = append(fake.setTargetInformationArgsForCall, struct {
		arg1 configv3.TargetInformationArgs
	}{arg1})
	stub := fake.SetTargetInformationStub
	fake.recordInvocation("SetTargetInformation", []interface{}{arg1})
	fake.setTargetInformationMutex.Unlock()
	if stub != nil {
		fake.SetTargetInformationStub(arg1)
	}
}

func (fake *FakeConfig) SetTargetInformationCallCount() int {
	fake.setTargetInformationMutex.RLock()
	defer fake.setTargetInformationMutex.RUnlock()
	return len(fake.setTargetInformationArgsForCall)
}

func (fake *FakeConfig) SetTargetInformationCalls(stub func(configv3.TargetInformationArgs)) {
	fake.setTargetInformationMutex.Lock()
	defer fake.setTargetInformationMutex.Unlock()
	fake.SetTargetInformationStub = stub
}

func (fake *FakeConfig) SetTargetInformationArgsForCall(i int) configv3.TargetInformationArgs {
	fake.setTargetInformationMutex.RLock()
	defer fake.setTargetInformationMutex.RUnlock()
	argsForCall := fake.setTargetInformationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetTokenInformation(arg1 string, arg2 string, arg3 string) {
	fake.setTokenInformationMutex.Lock()
	fake.setTokenInformationArgsForCall = append(fake.setTokenInformationArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.SetTokenInformationStub
	fake.recordInvocation("SetTokenInformation", []interface{}{arg1, arg2, arg3})
	fake.setTokenInformationMutex.Unlock()
	if stub != nil {
		fake.SetTokenInformationStub(arg1, arg2, arg3)
	}
}

func (fake *FakeConfig) SetTokenInformationCallCount() int {
	fake.setTokenInformationMutex.RLock()
	defer fake.setTokenInformationMutex.RUnlock()
	return len(fake.setTokenInformationArgsForCall)
}

func (fake *FakeConfig) SetTokenInformationCalls(stub func(string, string, string)) {
	fake.setTokenInformationMutex.Lock()
	defer fake.setTokenInformationMutex.Unlock()
	fake.SetTokenInformationStub = stub
}

func (fake *FakeConfig) SetTokenInformationArgsForCall(i int) (string, string, string) {
	fake.setTokenInformationMutex.RLock()
	defer fake.setTokenInformationMutex.RUnlock()
	argsForCall := fake.setTokenInformationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeConfig) SetTrace(arg1 string) {
	fake.setTraceMutex.Lock()
	fake.setTraceArgsForCall = append(fake.setTraceArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetTraceStub
	fake.recordInvocation("SetTrace", []interface{}{arg1})
	fake.setTraceMutex.Unlock()
	if stub != nil {
		fake.SetTraceStub(arg1)
	}
}

func (fake *FakeConfig) SetTraceCallCount() int {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	return len(fake.setTraceArgsForCall)
}

func (fake *FakeConfig) SetTraceCalls(stub func(string)) {
	fake.setTraceMutex.Lock()
	defer fake.setTraceMutex.Unlock()
	fake.SetTraceStub = stub
}

func (fake *FakeConfig) SetTraceArgsForCall(i int) string {
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	argsForCall := fake.setTraceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetUAAClientCredentials(arg1 string, arg2 string) {
	fake.setUAAClientCredentialsMutex.Lock()
	fake.setUAAClientCredentialsArgsForCall = append(fake.setUAAClientCredentialsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.SetUAAClientCredentialsStub
	fake.recordInvocation("SetUAAClientCredentials", []interface{}{arg1, arg2})
	fake.setUAAClientCredentialsMutex.Unlock()
	if stub != nil {
		fake.SetUAAClientCredentialsStub(arg1, arg2)
	}
}

func (fake *FakeConfig) SetUAAClientCredentialsCallCount() int {
	fake.setUAAClientCredentialsMutex.RLock()
	defer fake.setUAAClientCredentialsMutex.RUnlock()
	return len(fake.setUAAClientCredentialsArgsForCall)
}

func (fake *FakeConfig) SetUAAClientCredentialsCalls(stub func(string, string)) {
	fake.setUAAClientCredentialsMutex.Lock()
	defer fake.setUAAClientCredentialsMutex.Unlock()
	fake.SetUAAClientCredentialsStub = stub
}

func (fake *FakeConfig) SetUAAClientCredentialsArgsForCall(i int) (string, string) {
	fake.setUAAClientCredentialsMutex.RLock()
	defer fake.setUAAClientCredentialsMutex.RUnlock()
	argsForCall := fake.setUAAClientCredentialsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeConfig) SetUAAEndpoint(arg1 string) {
	fake.setUAAEndpointMutex.Lock()
	fake.setUAAEndpointArgsForCall = append(fake.setUAAEndpointArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetUAAEndpointStub
	fake.recordInvocation("SetUAAEndpoint", []interface{}{arg1})
	fake.setUAAEndpointMutex.Unlock()
	if stub != nil {
		fake.SetUAAEndpointStub(arg1)
	}
}

func (fake *FakeConfig) SetUAAEndpointCallCount() int {
	fake.setUAAEndpointMutex.RLock()
	defer fake.setUAAEndpointMutex.RUnlock()
	return len(fake.setUAAEndpointArgsForCall)
}

func (fake *FakeConfig) SetUAAEndpointCalls(stub func(string)) {
	fake.setUAAEndpointMutex.Lock()
	defer fake.setUAAEndpointMutex.Unlock()
	fake.SetUAAEndpointStub = stub
}

func (fake *FakeConfig) SetUAAEndpointArgsForCall(i int) string {
	fake.setUAAEndpointMutex.RLock()
	defer fake.setUAAEndpointMutex.RUnlock()
	argsForCall := fake.setUAAEndpointArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SetUAAGrantType(arg1 string) {
	fake.setUAAGrantTypeMutex.Lock()
	fake.setUAAGrantTypeArgsForCall = append(fake.setUAAGrantTypeArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.SetUAAGrantTypeStub
	fake.recordInvocation("SetUAAGrantType", []interface{}{arg1})
	fake.setUAAGrantTypeMutex.Unlock()
	if stub != nil {
		fake.SetUAAGrantTypeStub(arg1)
	}
}

func (fake *FakeConfig) SetUAAGrantTypeCallCount() int {
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	return len(fake.setUAAGrantTypeArgsForCall)
}

func (fake *FakeConfig) SetUAAGrantTypeCalls(stub func(string)) {
	fake.setUAAGrantTypeMutex.Lock()
	defer fake.setUAAGrantTypeMutex.Unlock()
	fake.SetUAAGrantTypeStub = stub
}

func (fake *FakeConfig) SetUAAGrantTypeArgsForCall(i int) string {
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	argsForCall := fake.setUAAGrantTypeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeConfig) SkipSSLValidation() bool {
	fake.skipSSLValidationMutex.Lock()
	ret, specificReturn := fake.skipSSLValidationReturnsOnCall[len(fake.skipSSLValidationArgsForCall)]
	fake.skipSSLValidationArgsForCall = append(fake.skipSSLValidationArgsForCall, struct {
	}{})
	stub := fake.SkipSSLValidationStub
	fakeReturns := fake.skipSSLValidationReturns
	fake.recordInvocation("SkipSSLValidation", []interface{}{})
	fake.skipSSLValidationMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) SkipSSLValidationCallCount() int {
	fake.skipSSLValidationMutex.RLock()
	defer fake.skipSSLValidationMutex.RUnlock()
	return len(fake.skipSSLValidationArgsForCall)
}

func (fake *FakeConfig) SkipSSLValidationCalls(stub func() bool) {
	fake.skipSSLValidationMutex.Lock()
	defer fake.skipSSLValidationMutex.Unlock()
	fake.SkipSSLValidationStub = stub
}

func (fake *FakeConfig) SkipSSLValidationReturns(result1 bool) {
	fake.skipSSLValidationMutex.Lock()
	defer fake.skipSSLValidationMutex.Unlock()
	fake.SkipSSLValidationStub = nil
	fake.skipSSLValidationReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) SkipSSLValidationReturnsOnCall(i int, result1 bool) {
	fake.skipSSLValidationMutex.Lock()
	defer fake.skipSSLValidationMutex.Unlock()
	fake.SkipSSLValidationStub = nil
	if fake.skipSSLValidationReturnsOnCall == nil {
		fake.skipSSLValidationReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.skipSSLValidationReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) StagingTimeout() time.Duration {
	fake.stagingTimeoutMutex.Lock()
	ret, specificReturn := fake.stagingTimeoutReturnsOnCall[len(fake.stagingTimeoutArgsForCall)]
	fake.stagingTimeoutArgsForCall = append(fake.stagingTimeoutArgsForCall, struct {
	}{})
	stub := fake.StagingTimeoutStub
	fakeReturns := fake.stagingTimeoutReturns
	fake.recordInvocation("StagingTimeout", []interface{}{})
	fake.stagingTimeoutMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) StagingTimeoutCallCount() int {
	fake.stagingTimeoutMutex.RLock()
	defer fake.stagingTimeoutMutex.RUnlock()
	return len(fake.stagingTimeoutArgsForCall)
}

func (fake *FakeConfig) StagingTimeoutCalls(stub func() time.Duration) {
	fake.stagingTimeoutMutex.Lock()
	defer fake.stagingTimeoutMutex.Unlock()
	fake.StagingTimeoutStub = stub
}

func (fake *FakeConfig) StagingTimeoutReturns(result1 time.Duration) {
	fake.stagingTimeoutMutex.Lock()
	defer fake.stagingTimeoutMutex.Unlock()
	fake.StagingTimeoutStub = nil
	fake.stagingTimeoutReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) StagingTimeoutReturnsOnCall(i int, result1 time.Duration) {
	fake.stagingTimeoutMutex.Lock()
	defer fake.stagingTimeoutMutex.Unlock()
	fake.StagingTimeoutStub = nil
	if fake.stagingTimeoutReturnsOnCall == nil {
		fake.stagingTimeoutReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.stagingTimeoutReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) StartupTimeout() time.Duration {
	fake.startupTimeoutMutex.Lock()
	ret, specificReturn := fake.startupTimeoutReturnsOnCall[len(fake.startupTimeoutArgsForCall)]
	fake.startupTimeoutArgsForCall = append(fake.startupTimeoutArgsForCall, struct {
	}{})
	stub := fake.StartupTimeoutStub
	fakeReturns := fake.startupTimeoutReturns
	fake.recordInvocation("StartupTimeout", []interface{}{})
	fake.startupTimeoutMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) StartupTimeoutCallCount() int {
	fake.startupTimeoutMutex.RLock()
	defer fake.startupTimeoutMutex.RUnlock()
	return len(fake.startupTimeoutArgsForCall)
}

func (fake *FakeConfig) StartupTimeoutCalls(stub func() time.Duration) {
	fake.startupTimeoutMutex.Lock()
	defer fake.startupTimeoutMutex.Unlock()
	fake.StartupTimeoutStub = stub
}

func (fake *FakeConfig) StartupTimeoutReturns(result1 time.Duration) {
	fake.startupTimeoutMutex.Lock()
	defer fake.startupTimeoutMutex.Unlock()
	fake.StartupTimeoutStub = nil
	fake.startupTimeoutReturns = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) StartupTimeoutReturnsOnCall(i int, result1 time.Duration) {
	fake.startupTimeoutMutex.Lock()
	defer fake.startupTimeoutMutex.Unlock()
	fake.StartupTimeoutStub = nil
	if fake.startupTimeoutReturnsOnCall == nil {
		fake.startupTimeoutReturnsOnCall = make(map[int]struct {
			result1 time.Duration
		})
	}
	fake.startupTimeoutReturnsOnCall[i] = struct {
		result1 time.Duration
	}{result1}
}

func (fake *FakeConfig) Target() string {
	fake.targetMutex.Lock()
	ret, specificReturn := fake.targetReturnsOnCall[len(fake.targetArgsForCall)]
	fake.targetArgsForCall = append(fake.targetArgsForCall, struct {
	}{})
	stub := fake.TargetStub
	fakeReturns := fake.targetReturns
	fake.recordInvocation("Target", []interface{}{})
	fake.targetMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) TargetCallCount() int {
	fake.targetMutex.RLock()
	defer fake.targetMutex.RUnlock()
	return len(fake.targetArgsForCall)
}

func (fake *FakeConfig) TargetCalls(stub func() string) {
	fake.targetMutex.Lock()
	defer fake.targetMutex.Unlock()
	fake.TargetStub = stub
}

func (fake *FakeConfig) TargetReturns(result1 string) {
	fake.targetMutex.Lock()
	defer fake.targetMutex.Unlock()
	fake.TargetStub = nil
	fake.targetReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) TargetReturnsOnCall(i int, result1 string) {
	fake.targetMutex.Lock()
	defer fake.targetMutex.Unlock()
	fake.TargetStub = nil
	if fake.targetReturnsOnCall == nil {
		fake.targetReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.targetReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) TargetedOrganization() configv3.Organization {
	fake.targetedOrganizationMutex.Lock()
	ret, specificReturn := fake.targetedOrganizationReturnsOnCall[len(fake.targetedOrganizationArgsForCall)]
	fake.targetedOrganizationArgsForCall = append(fake.targetedOrganizationArgsForCall, struct {
	}{})
	stub := fake.TargetedOrganizationStub
	fakeReturns := fake.targetedOrganizationReturns
	fake.recordInvocation("TargetedOrganization", []interface{}{})
	fake.targetedOrganizationMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) TargetedOrganizationCallCount() int {
	fake.targetedOrganizationMutex.RLock()
	defer fake.targetedOrganizationMutex.RUnlock()
	return len(fake.targetedOrganizationArgsForCall)
}

func (fake *FakeConfig) TargetedOrganizationCalls(stub func() configv3.Organization) {
	fake.targetedOrganizationMutex.Lock()
	defer fake.targetedOrganizationMutex.Unlock()
	fake.TargetedOrganizationStub = stub
}

func (fake *FakeConfig) TargetedOrganizationReturns(result1 configv3.Organization) {
	fake.targetedOrganizationMutex.Lock()
	defer fake.targetedOrganizationMutex.Unlock()
	fake.TargetedOrganizationStub = nil
	fake.targetedOrganizationReturns = struct {
		result1 configv3.Organization
	}{result1}
}

func (fake *FakeConfig) TargetedOrganizationReturnsOnCall(i int, result1 configv3.Organization) {
	fake.targetedOrganizationMutex.Lock()
	defer fake.targetedOrganizationMutex.Unlock()
	fake.TargetedOrganizationStub = nil
	if fake.targetedOrganizationReturnsOnCall == nil {
		fake.targetedOrganizationReturnsOnCall = make(map[int]struct {
			result1 configv3.Organization
		})
	}
	fake.targetedOrganizationReturnsOnCall[i] = struct {
		result1 configv3.Organization
	}{result1}
}

func (fake *FakeConfig) TargetedOrganizationName() string {
	fake.targetedOrganizationNameMutex.Lock()
	ret, specificReturn := fake.targetedOrganizationNameReturnsOnCall[len(fake.targetedOrganizationNameArgsForCall)]
	fake.targetedOrganizationNameArgsForCall = append(fake.targetedOrganizationNameArgsForCall, struct {
	}{})
	stub := fake.TargetedOrganizationNameStub
	fakeReturns := fake.targetedOrganizationNameReturns
	fake.recordInvocation("TargetedOrganizationName", []interface{}{})
	fake.targetedOrganizationNameMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) TargetedOrganizationNameCallCount() int {
	fake.targetedOrganizationNameMutex.RLock()
	defer fake.targetedOrganizationNameMutex.RUnlock()
	return len(fake.targetedOrganizationNameArgsForCall)
}

func (fake *FakeConfig) TargetedOrganizationNameCalls(stub func() string) {
	fake.targetedOrganizationNameMutex.Lock()
	defer fake.targetedOrganizationNameMutex.Unlock()
	fake.TargetedOrganizationNameStub = stub
}

func (fake *FakeConfig) TargetedOrganizationNameReturns(result1 string) {
	fake.targetedOrganizationNameMutex.Lock()
	defer fake.targetedOrganizationNameMutex.Unlock()
	fake.TargetedOrganizationNameStub = nil
	fake.targetedOrganizationNameReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) TargetedOrganizationNameReturnsOnCall(i int, result1 string) {
	fake.targetedOrganizationNameMutex.Lock()
	defer fake.targetedOrganizationNameMutex.Unlock()
	fake.TargetedOrganizationNameStub = nil
	if fake.targetedOrganizationNameReturnsOnCall == nil {
		fake.targetedOrganizationNameReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.targetedOrganizationNameReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) TargetedSpace() configv3.Space {
	fake.targetedSpaceMutex.Lock()
	ret, specificReturn := fake.targetedSpaceReturnsOnCall[len(fake.targetedSpaceArgsForCall)]
	fake.targetedSpaceArgsForCall = append(fake.targetedSpaceArgsForCall, struct {
	}{})
	stub := fake.TargetedSpaceStub
	fakeReturns := fake.targetedSpaceReturns
	fake.recordInvocation("TargetedSpace", []interface{}{})
	fake.targetedSpaceMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) TargetedSpaceCallCount() int {
	fake.targetedSpaceMutex.RLock()
	defer fake.targetedSpaceMutex.RUnlock()
	return len(fake.targetedSpaceArgsForCall)
}

func (fake *FakeConfig) TargetedSpaceCalls(stub func() configv3.Space) {
	fake.targetedSpaceMutex.Lock()
	defer fake.targetedSpaceMutex.Unlock()
	fake.TargetedSpaceStub = stub
}

func (fake *FakeConfig) TargetedSpaceReturns(result1 configv3.Space) {
	fake.targetedSpaceMutex.Lock()
	defer fake.targetedSpaceMutex.Unlock()
	fake.TargetedSpaceStub = nil
	fake.targetedSpaceReturns = struct {
		result1 configv3.Space
	}{result1}
}

func (fake *FakeConfig) TargetedSpaceReturnsOnCall(i int, result1 configv3.Space) {
	fake.targetedSpaceMutex.Lock()
	defer fake.targetedSpaceMutex.Unlock()
	fake.TargetedSpaceStub = nil
	if fake.targetedSpaceReturnsOnCall == nil {
		fake.targetedSpaceReturnsOnCall = make(map[int]struct {
			result1 configv3.Space
		})
	}
	fake.targetedSpaceReturnsOnCall[i] = struct {
		result1 configv3.Space
	}{result1}
}

func (fake *FakeConfig) TerminalWidth() int {
	fake.terminalWidthMutex.Lock()
	ret, specificReturn := fake.terminalWidthReturnsOnCall[len(fake.terminalWidthArgsForCall)]
	fake.terminalWidthArgsForCall = append(fake.terminalWidthArgsForCall, struct {
	}{})
	stub := fake.TerminalWidthStub
	fakeReturns := fake.terminalWidthReturns
	fake.recordInvocation("TerminalWidth", []interface{}{})
	fake.terminalWidthMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) TerminalWidthCallCount() int {
	fake.terminalWidthMutex.RLock()
	defer fake.terminalWidthMutex.RUnlock()
	return len(fake.terminalWidthArgsForCall)
}

func (fake *FakeConfig) TerminalWidthCalls(stub func() int) {
	fake.terminalWidthMutex.Lock()
	defer fake.terminalWidthMutex.Unlock()
	fake.TerminalWidthStub = stub
}

func (fake *FakeConfig) TerminalWidthReturns(result1 int) {
	fake.terminalWidthMutex.Lock()
	defer fake.terminalWidthMutex.Unlock()
	fake.TerminalWidthStub = nil
	fake.terminalWidthReturns = struct {
		result1 int
	}{result1}
}

func (fake *FakeConfig) TerminalWidthReturnsOnCall(i int, result1 int) {
	fake.terminalWidthMutex.Lock()
	defer fake.terminalWidthMutex.Unlock()
	fake.TerminalWidthStub = nil
	if fake.terminalWidthReturnsOnCall == nil {
		fake.terminalWidthReturnsOnCall = make(map[int]struct {
			result1 int
		})
	}
	fake.terminalWidthReturnsOnCall[i] = struct {
		result1 int
	}{result1}
}

func (fake *FakeConfig) UAADisableKeepAlives() bool {
	fake.uAADisableKeepAlivesMutex.Lock()
	ret, specificReturn := fake.uAADisableKeepAlivesReturnsOnCall[len(fake.uAADisableKeepAlivesArgsForCall)]
	fake.uAADisableKeepAlivesArgsForCall = append(fake.uAADisableKeepAlivesArgsForCall, struct {
	}{})
	stub := fake.UAADisableKeepAlivesStub
	fakeReturns := fake.uAADisableKeepAlivesReturns
	fake.recordInvocation("UAADisableKeepAlives", []interface{}{})
	fake.uAADisableKeepAlivesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) UAADisableKeepAlivesCallCount() int {
	fake.uAADisableKeepAlivesMutex.RLock()
	defer fake.uAADisableKeepAlivesMutex.RUnlock()
	return len(fake.uAADisableKeepAlivesArgsForCall)
}

func (fake *FakeConfig) UAADisableKeepAlivesCalls(stub func() bool) {
	fake.uAADisableKeepAlivesMutex.Lock()
	defer fake.uAADisableKeepAlivesMutex.Unlock()
	fake.UAADisableKeepAlivesStub = stub
}

func (fake *FakeConfig) UAADisableKeepAlivesReturns(result1 bool) {
	fake.uAADisableKeepAlivesMutex.Lock()
	defer fake.uAADisableKeepAlivesMutex.Unlock()
	fake.UAADisableKeepAlivesStub = nil
	fake.uAADisableKeepAlivesReturns = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) UAADisableKeepAlivesReturnsOnCall(i int, result1 bool) {
	fake.uAADisableKeepAlivesMutex.Lock()
	defer fake.uAADisableKeepAlivesMutex.Unlock()
	fake.UAADisableKeepAlivesStub = nil
	if fake.uAADisableKeepAlivesReturnsOnCall == nil {
		fake.uAADisableKeepAlivesReturnsOnCall = make(map[int]struct {
			result1 bool
		})
	}
	fake.uAADisableKeepAlivesReturnsOnCall[i] = struct {
		result1 bool
	}{result1}
}

func (fake *FakeConfig) UAAEndpoint() string {
	fake.uAAEndpointMutex.Lock()
	ret, specificReturn := fake.uAAEndpointReturnsOnCall[len(fake.uAAEndpointArgsForCall)]
	fake.uAAEndpointArgsForCall = append(fake.uAAEndpointArgsForCall, struct {
	}{})
	stub := fake.UAAEndpointStub
	fakeReturns := fake.uAAEndpointReturns
	fake.recordInvocation("UAAEndpoint", []interface{}{})
	fake.uAAEndpointMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) UAAEndpointCallCount() int {
	fake.uAAEndpointMutex.RLock()
	defer fake.uAAEndpointMutex.RUnlock()
	return len(fake.uAAEndpointArgsForCall)
}

func (fake *FakeConfig) UAAEndpointCalls(stub func() string) {
	fake.uAAEndpointMutex.Lock()
	defer fake.uAAEndpointMutex.Unlock()
	fake.UAAEndpointStub = stub
}

func (fake *FakeConfig) UAAEndpointReturns(result1 string) {
	fake.uAAEndpointMutex.Lock()
	defer fake.uAAEndpointMutex.Unlock()
	fake.UAAEndpointStub = nil
	fake.uAAEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAEndpointReturnsOnCall(i int, result1 string) {
	fake.uAAEndpointMutex.Lock()
	defer fake.uAAEndpointMutex.Unlock()
	fake.UAAEndpointStub = nil
	if fake.uAAEndpointReturnsOnCall == nil {
		fake.uAAEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAGrantType() string {
	fake.uAAGrantTypeMutex.Lock()
	ret, specificReturn := fake.uAAGrantTypeReturnsOnCall[len(fake.uAAGrantTypeArgsForCall)]
	fake.uAAGrantTypeArgsForCall = append(fake.uAAGrantTypeArgsForCall, struct {
	}{})
	stub := fake.UAAGrantTypeStub
	fakeReturns := fake.uAAGrantTypeReturns
	fake.recordInvocation("UAAGrantType", []interface{}{})
	fake.uAAGrantTypeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) UAAGrantTypeCallCount() int {
	fake.uAAGrantTypeMutex.RLock()
	defer fake.uAAGrantTypeMutex.RUnlock()
	return len(fake.uAAGrantTypeArgsForCall)
}

func (fake *FakeConfig) UAAGrantTypeCalls(stub func() string) {
	fake.uAAGrantTypeMutex.Lock()
	defer fake.uAAGrantTypeMutex.Unlock()
	fake.UAAGrantTypeStub = stub
}

func (fake *FakeConfig) UAAGrantTypeReturns(result1 string) {
	fake.uAAGrantTypeMutex.Lock()
	defer fake.uAAGrantTypeMutex.Unlock()
	fake.UAAGrantTypeStub = nil
	fake.uAAGrantTypeReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAGrantTypeReturnsOnCall(i int, result1 string) {
	fake.uAAGrantTypeMutex.Lock()
	defer fake.uAAGrantTypeMutex.Unlock()
	fake.UAAGrantTypeStub = nil
	if fake.uAAGrantTypeReturnsOnCall == nil {
		fake.uAAGrantTypeReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAGrantTypeReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAOAuthClient() string {
	fake.uAAOAuthClientMutex.Lock()
	ret, specificReturn := fake.uAAOAuthClientReturnsOnCall[len(fake.uAAOAuthClientArgsForCall)]
	fake.uAAOAuthClientArgsForCall = append(fake.uAAOAuthClientArgsForCall, struct {
	}{})
	stub := fake.UAAOAuthClientStub
	fakeReturns := fake.uAAOAuthClientReturns
	fake.recordInvocation("UAAOAuthClient", []interface{}{})
	fake.uAAOAuthClientMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) UAAOAuthClientCallCount() int {
	fake.uAAOAuthClientMutex.RLock()
	defer fake.uAAOAuthClientMutex.RUnlock()
	return len(fake.uAAOAuthClientArgsForCall)
}

func (fake *FakeConfig) UAAOAuthClientCalls(stub func() string) {
	fake.uAAOAuthClientMutex.Lock()
	defer fake.uAAOAuthClientMutex.Unlock()
	fake.UAAOAuthClientStub = stub
}

func (fake *FakeConfig) UAAOAuthClientReturns(result1 string) {
	fake.uAAOAuthClientMutex.Lock()
	defer fake.uAAOAuthClientMutex.Unlock()
	fake.UAAOAuthClientStub = nil
	fake.uAAOAuthClientReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAOAuthClientReturnsOnCall(i int, result1 string) {
	fake.uAAOAuthClientMutex.Lock()
	defer fake.uAAOAuthClientMutex.Unlock()
	fake.UAAOAuthClientStub = nil
	if fake.uAAOAuthClientReturnsOnCall == nil {
		fake.uAAOAuthClientReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAOAuthClientReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAOAuthClientSecret() string {
	fake.uAAOAuthClientSecretMutex.Lock()
	ret, specificReturn := fake.uAAOAuthClientSecretReturnsOnCall[len(fake.uAAOAuthClientSecretArgsForCall)]
	fake.uAAOAuthClientSecretArgsForCall = append(fake.uAAOAuthClientSecretArgsForCall, struct {
	}{})
	stub := fake.UAAOAuthClientSecretStub
	fakeReturns := fake.uAAOAuthClientSecretReturns
	fake.recordInvocation("UAAOAuthClientSecret", []interface{}{})
	fake.uAAOAuthClientSecretMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) UAAOAuthClientSecretCallCount() int {
	fake.uAAOAuthClientSecretMutex.RLock()
	defer fake.uAAOAuthClientSecretMutex.RUnlock()
	return len(fake.uAAOAuthClientSecretArgsForCall)
}

func (fake *FakeConfig) UAAOAuthClientSecretCalls(stub func() string) {
	fake.uAAOAuthClientSecretMutex.Lock()
	defer fake.uAAOAuthClientSecretMutex.Unlock()
	fake.UAAOAuthClientSecretStub = stub
}

func (fake *FakeConfig) UAAOAuthClientSecretReturns(result1 string) {
	fake.uAAOAuthClientSecretMutex.Lock()
	defer fake.uAAOAuthClientSecretMutex.Unlock()
	fake.UAAOAuthClientSecretStub = nil
	fake.uAAOAuthClientSecretReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UAAOAuthClientSecretReturnsOnCall(i int, result1 string) {
	fake.uAAOAuthClientSecretMutex.Lock()
	defer fake.uAAOAuthClientSecretMutex.Unlock()
	fake.UAAOAuthClientSecretStub = nil
	if fake.uAAOAuthClientSecretReturnsOnCall == nil {
		fake.uAAOAuthClientSecretReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.uAAOAuthClientSecretReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeConfig) UnsetOrganizationAndSpaceInformation() {
	fake.unsetOrganizationAndSpaceInformationMutex.Lock()
	fake.unsetOrganizationAndSpaceInformationArgsForCall = append(fake.unsetOrganizationAndSpaceInformationArgsForCall, struct {
	}{})
	stub := fake.UnsetOrganizationAndSpaceInformationStub
	fake.recordInvocation("UnsetOrganizationAndSpaceInformation", []interface{}{})
	fake.unsetOrganizationAndSpaceInformationMutex.Unlock()
	if stub != nil {
		fake.UnsetOrganizationAndSpaceInformationStub()
	}
}

func (fake *FakeConfig) UnsetOrganizationAndSpaceInformationCallCount() int {
	fake.unsetOrganizationAndSpaceInformationMutex.RLock()
	defer fake.unsetOrganizationAndSpaceInformationMutex.RUnlock()
	return len(fake.unsetOrganizationAndSpaceInformationArgsForCall)
}

func (fake *FakeConfig) UnsetOrganizationAndSpaceInformationCalls(stub func()) {
	fake.unsetOrganizationAndSpaceInformationMutex.Lock()
	defer fake.unsetOrganizationAndSpaceInformationMutex.Unlock()
	fake.UnsetOrganizationAndSpaceInformationStub = stub
}

func (fake *FakeConfig) UnsetSpaceInformation() {
	fake.unsetSpaceInformationMutex.Lock()
	fake.unsetSpaceInformationArgsForCall = append(fake.unsetSpaceInformationArgsForCall, struct {
	}{})
	stub := fake.UnsetSpaceInformationStub
	fake.recordInvocation("UnsetSpaceInformation", []interface{}{})
	fake.unsetSpaceInformationMutex.Unlock()
	if stub != nil {
		fake.UnsetSpaceInformationStub()
	}
}

func (fake *FakeConfig) UnsetSpaceInformationCallCount() int {
	fake.unsetSpaceInformationMutex.RLock()
	defer fake.unsetSpaceInformationMutex.RUnlock()
	return len(fake.unsetSpaceInformationArgsForCall)
}

func (fake *FakeConfig) UnsetSpaceInformationCalls(stub func()) {
	fake.unsetSpaceInformationMutex.Lock()
	defer fake.unsetSpaceInformationMutex.Unlock()
	fake.UnsetSpaceInformationStub = stub
}

func (fake *FakeConfig) UnsetUserInformation() {
	fake.unsetUserInformationMutex.Lock()
	fake.unsetUserInformationArgsForCall = append(fake.unsetUserInformationArgsForCall, struct {
	}{})
	stub := fake.UnsetUserInformationStub
	fake.recordInvocation("UnsetUserInformation", []interface{}{})
	fake.unsetUserInformationMutex.Unlock()
	if stub != nil {
		fake.UnsetUserInformationStub()
	}
}

func (fake *FakeConfig) UnsetUserInformationCallCount() int {
	fake.unsetUserInformationMutex.RLock()
	defer fake.unsetUserInformationMutex.RUnlock()
	return len(fake.unsetUserInformationArgsForCall)
}

func (fake *FakeConfig) UnsetUserInformationCalls(stub func()) {
	fake.unsetUserInformationMutex.Lock()
	defer fake.unsetUserInformationMutex.Unlock()
	fake.UnsetUserInformationStub = stub
}

func (fake *FakeConfig) V7SetSpaceInformation(arg1 string, arg2 string) {
	fake.v7SetSpaceInformationMutex.Lock()
	fake.v7SetSpaceInformationArgsForCall = append(fake.v7SetSpaceInformationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.V7SetSpaceInformationStub
	fake.recordInvocation("V7SetSpaceInformation", []interface{}{arg1, arg2})
	fake.v7SetSpaceInformationMutex.Unlock()
	if stub != nil {
		fake.V7SetSpaceInformationStub(arg1, arg2)
	}
}

func (fake *FakeConfig) V7SetSpaceInformationCallCount() int {
	fake.v7SetSpaceInformationMutex.RLock()
	defer fake.v7SetSpaceInformationMutex.RUnlock()
	return len(fake.v7SetSpaceInformationArgsForCall)
}

func (fake *FakeConfig) V7SetSpaceInformationCalls(stub func(string, string)) {
	fake.v7SetSpaceInformationMutex.Lock()
	defer fake.v7SetSpaceInformationMutex.Unlock()
	fake.V7SetSpaceInformationStub = stub
}

func (fake *FakeConfig) V7SetSpaceInformationArgsForCall(i int) (string, string) {
	fake.v7SetSpaceInformationMutex.RLock()
	defer fake.v7SetSpaceInformationMutex.RUnlock()
	argsForCall := fake.v7SetSpaceInformationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeConfig) Verbose() (bool, []string) {
	fake.verboseMutex.Lock()
	ret, specificReturn := fake.verboseReturnsOnCall[len(fake.verboseArgsForCall)]
	fake.verboseArgsForCall = append(fake.verboseArgsForCall, struct {
	}{})
	stub := fake.VerboseStub
	fakeReturns := fake.verboseReturns
	fake.recordInvocation("Verbose", []interface{}{})
	fake.verboseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeConfig) VerboseCallCount() int {
	fake.verboseMutex.RLock()
	defer fake.verboseMutex.RUnlock()
	return len(fake.verboseArgsForCall)
}

func (fake *FakeConfig) VerboseCalls(stub func() (bool, []string)) {
	fake.verboseMutex.Lock()
	defer fake.verboseMutex.Unlock()
	fake.VerboseStub = stub
}

func (fake *FakeConfig) VerboseReturns(result1 bool, result2 []string) {
	fake.verboseMutex.Lock()
	defer fake.verboseMutex.Unlock()
	fake.VerboseStub = nil
	fake.verboseReturns = struct {
		result1 bool
		result2 []string
	}{result1, result2}
}

func (fake *FakeConfig) VerboseReturnsOnCall(i int, result1 bool, result2 []string) {
	fake.verboseMutex.Lock()
	defer fake.verboseMutex.Unlock()
	fake.VerboseStub = nil
	if fake.verboseReturnsOnCall == nil {
		fake.verboseReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 []string
		})
	}
	fake.verboseReturnsOnCall[i] = struct {
		result1 bool
		result2 []string
	}{result1, result2}
}

func (fake *FakeConfig) WriteConfig() error {
	fake.writeConfigMutex.Lock()
	ret, specificReturn := fake.writeConfigReturnsOnCall[len(fake.writeConfigArgsForCall)]
	fake.writeConfigArgsForCall = append(fake.writeConfigArgsForCall, struct {
	}{})
	stub := fake.WriteConfigStub
	fakeReturns := fake.writeConfigReturns
	fake.recordInvocation("WriteConfig", []interface{}{})
	fake.writeConfigMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) WriteConfigCallCount() int {
	fake.writeConfigMutex.RLock()
	defer fake.writeConfigMutex.RUnlock()
	return len(fake.writeConfigArgsForCall)
}

func (fake *FakeConfig) WriteConfigCalls(stub func() error) {
	fake.writeConfigMutex.Lock()
	defer fake.writeConfigMutex.Unlock()
	fake.WriteConfigStub = stub
}

func (fake *FakeConfig) WriteConfigReturns(result1 error) {
	fake.writeConfigMutex.Lock()
	defer fake.writeConfigMutex.Unlock()
	fake.WriteConfigStub = nil
	fake.writeConfigReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConfig) WriteConfigReturnsOnCall(i int, result1 error) {
	fake.writeConfigMutex.Lock()
	defer fake.writeConfigMutex.Unlock()
	fake.WriteConfigStub = nil
	if fake.writeConfigReturnsOnCall == nil {
		fake.writeConfigReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.writeConfigReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConfig) WritePluginConfig() error {
	fake.writePluginConfigMutex.Lock()
	ret, specificReturn := fake.writePluginConfigReturnsOnCall[len(fake.writePluginConfigArgsForCall)]
	fake.writePluginConfigArgsForCall = append(fake.writePluginConfigArgsForCall, struct {
	}{})
	stub := fake.WritePluginConfigStub
	fakeReturns := fake.writePluginConfigReturns
	fake.recordInvocation("WritePluginConfig", []interface{}{})
	fake.writePluginConfigMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeConfig) WritePluginConfigCallCount() int {
	fake.writePluginConfigMutex.RLock()
	defer fake.writePluginConfigMutex.RUnlock()
	return len(fake.writePluginConfigArgsForCall)
}

func (fake *FakeConfig) WritePluginConfigCalls(stub func() error) {
	fake.writePluginConfigMutex.Lock()
	defer fake.writePluginConfigMutex.Unlock()
	fake.WritePluginConfigStub = stub
}

func (fake *FakeConfig) WritePluginConfigReturns(result1 error) {
	fake.writePluginConfigMutex.Lock()
	defer fake.writePluginConfigMutex.Unlock()
	fake.WritePluginConfigStub = nil
	fake.writePluginConfigReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeConfig) WritePluginConfigReturnsOnCall(i int, result1 error) {
	fake.writePluginConfigMutex.Lock()
	defer fake.writePluginConfigMutex.Unlock()
	fake.WritePluginConfigStub = nil
	if fake.writePluginConfigReturnsOnCall == nil {
		fake.writePluginConfigReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.writePluginConfigReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeConfig) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	fake.accessTokenMutex.RLock()
	defer fake.accessTokenMutex.RUnlock()
	fake.addPluginMutex.RLock()
	defer fake.addPluginMutex.RUnlock()
	fake.addPluginRepositoryMutex.RLock()
	defer fake.addPluginRepositoryMutex.RUnlock()
	fake.authorizationEndpointMutex.RLock()
	defer fake.authorizationEndpointMutex.RUnlock()
	fake.b3SpanIDMutex.RLock()
	defer fake.b3SpanIDMutex.RUnlock()
	fake.b3TraceIDMutex.RLock()
	defer fake.b3TraceIDMutex.RUnlock()
	fake.binaryNameMutex.RLock()
	defer fake.binaryNameMutex.RUnlock()
	fake.binaryVersionMutex.RLock()
	defer fake.binaryVersionMutex.RUnlock()
	fake.cFPasswordMutex.RLock()
	defer fake.cFPasswordMutex.RUnlock()
	fake.cFUsernameMutex.RLock()
	defer fake.cFUsernameMutex.RUnlock()
	fake.cNBCredentialsMutex.RLock()
	defer fake.cNBCredentialsMutex.RUnlock()
	fake.colorEnabledMutex.RLock()
	defer fake.colorEnabledMutex.RUnlock()
	fake.currentUserMutex.RLock()
	defer fake.currentUserMutex.RUnlock()
	fake.currentUserNameMutex.RLock()
	defer fake.currentUserNameMutex.RUnlock()
	fake.dialTimeoutMutex.RLock()
	defer fake.dialTimeoutMutex.RUnlock()
	fake.dockerPasswordMutex.RLock()
	defer fake.dockerPasswordMutex.RUnlock()
	fake.experimentalMutex.RLock()
	defer fake.experimentalMutex.RUnlock()
	fake.getPluginMutex.RLock()
	defer fake.getPluginMutex.RUnlock()
	fake.getPluginCaseInsensitiveMutex.RLock()
	defer fake.getPluginCaseInsensitiveMutex.RUnlock()
	fake.hasTargetedOrganizationMutex.RLock()
	defer fake.hasTargetedOrganizationMutex.RUnlock()
	fake.hasTargetedSpaceMutex.RLock()
	defer fake.hasTargetedSpaceMutex.RUnlock()
	fake.isCFOnK8sMutex.RLock()
	defer fake.isCFOnK8sMutex.RUnlock()
	fake.isTTYMutex.RLock()
	defer fake.isTTYMutex.RUnlock()
	fake.localeMutex.RLock()
	defer fake.localeMutex.RUnlock()
	fake.logCacheEndpointMutex.RLock()
	defer fake.logCacheEndpointMutex.RUnlock()
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	fake.nOAARequestRetryCountMutex.RLock()
	defer fake.nOAARequestRetryCountMutex.RUnlock()
	fake.networkPolicyV1EndpointMutex.RLock()
	defer fake.networkPolicyV1EndpointMutex.RUnlock()
	fake.overallPollingTimeoutMutex.RLock()
	defer fake.overallPollingTimeoutMutex.RUnlock()
	fake.pluginHomeMutex.RLock()
	defer fake.pluginHomeMutex.RUnlock()
	fake.pluginRepositoriesMutex.RLock()
	defer fake.pluginRepositoriesMutex.RUnlock()
	fake.pluginsMutex.RLock()
	defer fake.pluginsMutex.RUnlock()
	fake.pollingIntervalMutex.RLock()
	defer fake.pollingIntervalMutex.RUnlock()
	fake.refreshTokenMutex.RLock()
	defer fake.refreshTokenMutex.RUnlock()
	fake.removePluginMutex.RLock()
	defer fake.removePluginMutex.RUnlock()
	fake.requestRetryCountMutex.RLock()
	defer fake.requestRetryCountMutex.RUnlock()
	fake.routingEndpointMutex.RLock()
	defer fake.routingEndpointMutex.RUnlock()
	fake.sSHOAuthClientMutex.RLock()
	defer fake.sSHOAuthClientMutex.RUnlock()
	fake.setAccessTokenMutex.RLock()
	defer fake.setAccessTokenMutex.RUnlock()
	fake.setAsyncTimeoutMutex.RLock()
	defer fake.setAsyncTimeoutMutex.RUnlock()
	fake.setColorEnabledMutex.RLock()
	defer fake.setColorEnabledMutex.RUnlock()
	fake.setKubernetesAuthInfoMutex.RLock()
	defer fake.setKubernetesAuthInfoMutex.RUnlock()
	fake.setLocaleMutex.RLock()
	defer fake.setLocaleMutex.RUnlock()
	fake.setMinCLIVersionMutex.RLock()
	defer fake.setMinCLIVersionMutex.RUnlock()
	fake.setOrganizationInformationMutex.RLock()
	defer fake.setOrganizationInformationMutex.RUnlock()
	fake.setRefreshTokenMutex.RLock()
	defer fake.setRefreshTokenMutex.RUnlock()
	fake.setSpaceInformationMutex.RLock()
	defer fake.setSpaceInformationMutex.RUnlock()
	fake.setTargetInformationMutex.RLock()
	defer fake.setTargetInformationMutex.RUnlock()
	fake.setTokenInformationMutex.RLock()
	defer fake.setTokenInformationMutex.RUnlock()
	fake.setTraceMutex.RLock()
	defer fake.setTraceMutex.RUnlock()
	fake.setUAAClientCredentialsMutex.RLock()
	defer fake.setUAAClientCredentialsMutex.RUnlock()
	fake.setUAAEndpointMutex.RLock()
	defer fake.setUAAEndpointMutex.RUnlock()
	fake.setUAAGrantTypeMutex.RLock()
	defer fake.setUAAGrantTypeMutex.RUnlock()
	fake.skipSSLValidationMutex.RLock()
	defer fake.skipSSLValidationMutex.RUnlock()
	fake.stagingTimeoutMutex.RLock()
	defer fake.stagingTimeoutMutex.RUnlock()
	fake.startupTimeoutMutex.RLock()
	defer fake.startupTimeoutMutex.RUnlock()
	fake.targetMutex.RLock()
	defer fake.targetMutex.RUnlock()
	fake.targetedOrganizationMutex.RLock()
	defer fake.targetedOrganizationMutex.RUnlock()
	fake.targetedOrganizationNameMutex.RLock()
	defer fake.targetedOrganizationNameMutex.RUnlock()
	fake.targetedSpaceMutex.RLock()
	defer fake.targetedSpaceMutex.RUnlock()
	fake.terminalWidthMutex.RLock()
	defer fake.terminalWidthMutex.RUnlock()
	fake.uAADisableKeepAlivesMutex.RLock()
	defer fake.uAADisableKeepAlivesMutex.RUnlock()
	fake.uAAEndpointMutex.RLock()
	defer fake.uAAEndpointMutex.RUnlock()
	fake.uAAGrantTypeMutex.RLock()
	defer fake.uAAGrantTypeMutex.RUnlock()
	fake.uAAOAuthClientMutex.RLock()
	defer fake.uAAOAuthClientMutex.RUnlock()
	fake.uAAOAuthClientSecretMutex.RLock()
	defer fake.uAAOAuthClientSecretMutex.RUnlock()
	fake.unsetOrganizationAndSpaceInformationMutex.RLock()
	defer fake.unsetOrganizationAndSpaceInformationMutex.RUnlock()
	fake.unsetSpaceInformationMutex.RLock()
	defer fake.unsetSpaceInformationMutex.RUnlock()
	fake.unsetUserInformationMutex.RLock()
	defer fake.unsetUserInformationMutex.RUnlock()
	fake.v7SetSpaceInformationMutex.RLock()
	defer fake.v7SetSpaceInformationMutex.RUnlock()
	fake.verboseMutex.RLock()
	defer fake.verboseMutex.RUnlock()
	fake.writeConfigMutex.RLock()
	defer fake.writeConfigMutex.RUnlock()
	fake.writePluginConfigMutex.RLock()
	defer fake.writePluginConfigMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeConfig) recordInvocation(key string, args []interface{}) {
	fake.invocationsMutex.Lock()
	defer fake.invocationsMutex.Unlock()
	if fake.invocations == nil {
		fake.invocations = map[string][][]interface{}{}
	}
	if fake.invocations[key] == nil {
		fake.invocations[key] = [][]interface{}{}
	}
	fake.invocations[key] = append(fake.invocations[key], args)
}

var _ command.Config = new(FakeConfig)
