github.com/randomtask1155/cli@v6.41.1-0.20181227003417-a98eed78cbde+incompatible/actor/v2action/v2actionfakes/fake_cloud_controller_client.go

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

import (
	io "io"
	sync "sync"

	v2action "code.cloudfoundry.org/cli/actor/v2action"
	ccv2 "code.cloudfoundry.org/cli/api/cloudcontroller/ccv2"
)

type FakeCloudControllerClient struct {
	APIStub        func() string
	aPIMutex       sync.RWMutex
	aPIArgsForCall []struct {
	}
	aPIReturns struct {
		result1 string
	}
	aPIReturnsOnCall map[int]struct {
		result1 string
	}
	APIVersionStub        func() string
	aPIVersionMutex       sync.RWMutex
	aPIVersionArgsForCall []struct {
	}
	aPIVersionReturns struct {
		result1 string
	}
	aPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	AuthorizationEndpointStub        func() string
	authorizationEndpointMutex       sync.RWMutex
	authorizationEndpointArgsForCall []struct {
	}
	authorizationEndpointReturns struct {
		result1 string
	}
	authorizationEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	CheckRouteStub        func(ccv2.Route) (bool, ccv2.Warnings, error)
	checkRouteMutex       sync.RWMutex
	checkRouteArgsForCall []struct {
		arg1 ccv2.Route
	}
	checkRouteReturns struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}
	checkRouteReturnsOnCall map[int]struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}
	CreateApplicationStub        func(ccv2.Application) (ccv2.Application, ccv2.Warnings, error)
	createApplicationMutex       sync.RWMutex
	createApplicationArgsForCall []struct {
		arg1 ccv2.Application
	}
	createApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	createApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	CreateBuildpackStub        func(ccv2.Buildpack) (ccv2.Buildpack, ccv2.Warnings, error)
	createBuildpackMutex       sync.RWMutex
	createBuildpackArgsForCall []struct {
		arg1 ccv2.Buildpack
	}
	createBuildpackReturns struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}
	createBuildpackReturnsOnCall map[int]struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}
	CreateOrganizationStub        func(string, string) (ccv2.Organization, ccv2.Warnings, error)
	createOrganizationMutex       sync.RWMutex
	createOrganizationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createOrganizationReturns struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	createOrganizationReturnsOnCall map[int]struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	CreateRouteStub        func(ccv2.Route, bool) (ccv2.Route, ccv2.Warnings, error)
	createRouteMutex       sync.RWMutex
	createRouteArgsForCall []struct {
		arg1 ccv2.Route
		arg2 bool
	}
	createRouteReturns struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	createRouteReturnsOnCall map[int]struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	CreateServiceBindingStub        func(string, string, string, bool, map[string]interface{}) (ccv2.ServiceBinding, ccv2.Warnings, error)
	createServiceBindingMutex       sync.RWMutex
	createServiceBindingArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 bool
		arg5 map[string]interface{}
	}
	createServiceBindingReturns struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	createServiceBindingReturnsOnCall map[int]struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	CreateServiceBrokerStub        func(string, string, string, string, string) (ccv2.ServiceBroker, ccv2.Warnings, error)
	createServiceBrokerMutex       sync.RWMutex
	createServiceBrokerArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 string
	}
	createServiceBrokerReturns struct {
		result1 ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}
	createServiceBrokerReturnsOnCall map[int]struct {
		result1 ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}
	CreateServiceKeyStub        func(string, string, map[string]interface{}) (ccv2.ServiceKey, ccv2.Warnings, error)
	createServiceKeyMutex       sync.RWMutex
	createServiceKeyArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]interface{}
	}
	createServiceKeyReturns struct {
		result1 ccv2.ServiceKey
		result2 ccv2.Warnings
		result3 error
	}
	createServiceKeyReturnsOnCall map[int]struct {
		result1 ccv2.ServiceKey
		result2 ccv2.Warnings
		result3 error
	}
	CreateServicePlanVisibilityStub        func(string, string) (ccv2.ServicePlanVisibility, ccv2.Warnings, error)
	createServicePlanVisibilityMutex       sync.RWMutex
	createServicePlanVisibilityArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createServicePlanVisibilityReturns struct {
		result1 ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}
	createServicePlanVisibilityReturnsOnCall map[int]struct {
		result1 ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}
	CreateSharedDomainStub        func(string, string, bool) (ccv2.Warnings, error)
	createSharedDomainMutex       sync.RWMutex
	createSharedDomainArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	createSharedDomainReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	createSharedDomainReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	CreateSpaceStub        func(string, string) (ccv2.Space, ccv2.Warnings, error)
	createSpaceMutex       sync.RWMutex
	createSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createSpaceReturns struct {
		result1 ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	createSpaceReturnsOnCall map[int]struct {
		result1 ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	CreateUserStub        func(string) (ccv2.User, ccv2.Warnings, error)
	createUserMutex       sync.RWMutex
	createUserArgsForCall []struct {
		arg1 string
	}
	createUserReturns struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}
	createUserReturnsOnCall map[int]struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}
	DeleteOrganizationJobStub        func(string) (ccv2.Job, ccv2.Warnings, error)
	deleteOrganizationJobMutex       sync.RWMutex
	deleteOrganizationJobArgsForCall []struct {
		arg1 string
	}
	deleteOrganizationJobReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	deleteOrganizationJobReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	DeleteRouteStub        func(string) (ccv2.Warnings, error)
	deleteRouteMutex       sync.RWMutex
	deleteRouteArgsForCall []struct {
		arg1 string
	}
	deleteRouteReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	deleteRouteReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteRouteApplicationStub        func(string, string) (ccv2.Warnings, error)
	deleteRouteApplicationMutex       sync.RWMutex
	deleteRouteApplicationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteRouteApplicationReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	deleteRouteApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteSecurityGroupSpaceStub        func(string, string) (ccv2.Warnings, error)
	deleteSecurityGroupSpaceMutex       sync.RWMutex
	deleteSecurityGroupSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteSecurityGroupSpaceReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	deleteSecurityGroupSpaceReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteSecurityGroupStagingSpaceStub        func(string, string) (ccv2.Warnings, error)
	deleteSecurityGroupStagingSpaceMutex       sync.RWMutex
	deleteSecurityGroupStagingSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteSecurityGroupStagingSpaceReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	deleteSecurityGroupStagingSpaceReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteServiceBindingStub        func(string, bool) (ccv2.ServiceBinding, ccv2.Warnings, error)
	deleteServiceBindingMutex       sync.RWMutex
	deleteServiceBindingArgsForCall []struct {
		arg1 string
		arg2 bool
	}
	deleteServiceBindingReturns struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	deleteServiceBindingReturnsOnCall map[int]struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	DeleteServicePlanVisibilityStub        func(string) (ccv2.Warnings, error)
	deleteServicePlanVisibilityMutex       sync.RWMutex
	deleteServicePlanVisibilityArgsForCall []struct {
		arg1 string
	}
	deleteServicePlanVisibilityReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	deleteServicePlanVisibilityReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	DeleteSpaceJobStub        func(string) (ccv2.Job, ccv2.Warnings, error)
	deleteSpaceJobMutex       sync.RWMutex
	deleteSpaceJobArgsForCall []struct {
		arg1 string
	}
	deleteSpaceJobReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	deleteSpaceJobReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	DopplerEndpointStub        func() string
	dopplerEndpointMutex       sync.RWMutex
	dopplerEndpointArgsForCall []struct {
	}
	dopplerEndpointReturns struct {
		result1 string
	}
	dopplerEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	GetApplicationStub        func(string) (ccv2.Application, ccv2.Warnings, error)
	getApplicationMutex       sync.RWMutex
	getApplicationArgsForCall []struct {
		arg1 string
	}
	getApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	getApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationApplicationInstanceStatusesStub        func(string) (map[int]ccv2.ApplicationInstanceStatus, ccv2.Warnings, error)
	getApplicationApplicationInstanceStatusesMutex       sync.RWMutex
	getApplicationApplicationInstanceStatusesArgsForCall []struct {
		arg1 string
	}
	getApplicationApplicationInstanceStatusesReturns struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		result2 ccv2.Warnings
		result3 error
	}
	getApplicationApplicationInstanceStatusesReturnsOnCall map[int]struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationApplicationInstancesStub        func(string) (map[int]ccv2.ApplicationInstance, ccv2.Warnings, error)
	getApplicationApplicationInstancesMutex       sync.RWMutex
	getApplicationApplicationInstancesArgsForCall []struct {
		arg1 string
	}
	getApplicationApplicationInstancesReturns struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}
	getApplicationApplicationInstancesReturnsOnCall map[int]struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationRoutesStub        func(string, ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error)
	getApplicationRoutesMutex       sync.RWMutex
	getApplicationRoutesArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getApplicationRoutesReturns struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	getApplicationRoutesReturnsOnCall map[int]struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetApplicationsStub        func(...ccv2.Filter) ([]ccv2.Application, ccv2.Warnings, error)
	getApplicationsMutex       sync.RWMutex
	getApplicationsArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getApplicationsReturns struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	getApplicationsReturnsOnCall map[int]struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetBuildpacksStub        func(...ccv2.Filter) ([]ccv2.Buildpack, ccv2.Warnings, error)
	getBuildpacksMutex       sync.RWMutex
	getBuildpacksArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getBuildpacksReturns struct {
		result1 []ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}
	getBuildpacksReturnsOnCall map[int]struct {
		result1 []ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}
	GetConfigFeatureFlagsStub        func() ([]ccv2.FeatureFlag, ccv2.Warnings, error)
	getConfigFeatureFlagsMutex       sync.RWMutex
	getConfigFeatureFlagsArgsForCall []struct {
	}
	getConfigFeatureFlagsReturns struct {
		result1 []ccv2.FeatureFlag
		result2 ccv2.Warnings
		result3 error
	}
	getConfigFeatureFlagsReturnsOnCall map[int]struct {
		result1 []ccv2.FeatureFlag
		result2 ccv2.Warnings
		result3 error
	}
	GetJobStub        func(string) (ccv2.Job, ccv2.Warnings, error)
	getJobMutex       sync.RWMutex
	getJobArgsForCall []struct {
		arg1 string
	}
	getJobReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	getJobReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationStub        func(string) (ccv2.Organization, ccv2.Warnings, error)
	getOrganizationMutex       sync.RWMutex
	getOrganizationArgsForCall []struct {
		arg1 string
	}
	getOrganizationReturns struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationReturnsOnCall map[int]struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationPrivateDomainsStub        func(string, ...ccv2.Filter) ([]ccv2.Domain, ccv2.Warnings, error)
	getOrganizationPrivateDomainsMutex       sync.RWMutex
	getOrganizationPrivateDomainsArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getOrganizationPrivateDomainsReturns struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationPrivateDomainsReturnsOnCall map[int]struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationQuotaStub        func(string) (ccv2.OrganizationQuota, ccv2.Warnings, error)
	getOrganizationQuotaMutex       sync.RWMutex
	getOrganizationQuotaArgsForCall []struct {
		arg1 string
	}
	getOrganizationQuotaReturns struct {
		result1 ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationQuotaReturnsOnCall map[int]struct {
		result1 ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationQuotasStub        func(...ccv2.Filter) ([]ccv2.OrganizationQuota, ccv2.Warnings, error)
	getOrganizationQuotasMutex       sync.RWMutex
	getOrganizationQuotasArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getOrganizationQuotasReturns struct {
		result1 []ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationQuotasReturnsOnCall map[int]struct {
		result1 []ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}
	GetOrganizationsStub        func(...ccv2.Filter) ([]ccv2.Organization, ccv2.Warnings, error)
	getOrganizationsMutex       sync.RWMutex
	getOrganizationsArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getOrganizationsReturns struct {
		result1 []ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	getOrganizationsReturnsOnCall map[int]struct {
		result1 []ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}
	GetPrivateDomainStub        func(string) (ccv2.Domain, ccv2.Warnings, error)
	getPrivateDomainMutex       sync.RWMutex
	getPrivateDomainArgsForCall []struct {
		arg1 string
	}
	getPrivateDomainReturns struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	getPrivateDomainReturnsOnCall map[int]struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetRouteApplicationsStub        func(string, ...ccv2.Filter) ([]ccv2.Application, ccv2.Warnings, error)
	getRouteApplicationsMutex       sync.RWMutex
	getRouteApplicationsArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getRouteApplicationsReturns struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	getRouteApplicationsReturnsOnCall map[int]struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	GetRoutesStub        func(...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error)
	getRoutesMutex       sync.RWMutex
	getRoutesArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getRoutesReturns struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	getRoutesReturnsOnCall map[int]struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetSecurityGroupSpacesStub        func(string) ([]ccv2.Space, ccv2.Warnings, error)
	getSecurityGroupSpacesMutex       sync.RWMutex
	getSecurityGroupSpacesArgsForCall []struct {
		arg1 string
	}
	getSecurityGroupSpacesReturns struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	getSecurityGroupSpacesReturnsOnCall map[int]struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	GetSecurityGroupStagingSpacesStub        func(string) ([]ccv2.Space, ccv2.Warnings, error)
	getSecurityGroupStagingSpacesMutex       sync.RWMutex
	getSecurityGroupStagingSpacesArgsForCall []struct {
		arg1 string
	}
	getSecurityGroupStagingSpacesReturns struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	getSecurityGroupStagingSpacesReturnsOnCall map[int]struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	GetSecurityGroupsStub        func(...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error)
	getSecurityGroupsMutex       sync.RWMutex
	getSecurityGroupsArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getSecurityGroupsReturns struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	getSecurityGroupsReturnsOnCall map[int]struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceStub        func(string) (ccv2.Service, ccv2.Warnings, error)
	getServiceMutex       sync.RWMutex
	getServiceArgsForCall []struct {
		arg1 string
	}
	getServiceReturns struct {
		result1 ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}
	getServiceReturnsOnCall map[int]struct {
		result1 ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceBindingsStub        func(...ccv2.Filter) ([]ccv2.ServiceBinding, ccv2.Warnings, error)
	getServiceBindingsMutex       sync.RWMutex
	getServiceBindingsArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getServiceBindingsReturns struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	getServiceBindingsReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceBrokersStub        func(...ccv2.Filter) ([]ccv2.ServiceBroker, ccv2.Warnings, error)
	getServiceBrokersMutex       sync.RWMutex
	getServiceBrokersArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getServiceBrokersReturns struct {
		result1 []ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}
	getServiceBrokersReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstanceStub        func(string) (ccv2.ServiceInstance, ccv2.Warnings, error)
	getServiceInstanceMutex       sync.RWMutex
	getServiceInstanceArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceReturns struct {
		result1 ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	getServiceInstanceReturnsOnCall map[int]struct {
		result1 ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstanceServiceBindingsStub        func(string) ([]ccv2.ServiceBinding, ccv2.Warnings, error)
	getServiceInstanceServiceBindingsMutex       sync.RWMutex
	getServiceInstanceServiceBindingsArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceServiceBindingsReturns struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	getServiceInstanceServiceBindingsReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstanceSharedFromStub        func(string) (ccv2.ServiceInstanceSharedFrom, ccv2.Warnings, error)
	getServiceInstanceSharedFromMutex       sync.RWMutex
	getServiceInstanceSharedFromArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceSharedFromReturns struct {
		result1 ccv2.ServiceInstanceSharedFrom
		result2 ccv2.Warnings
		result3 error
	}
	getServiceInstanceSharedFromReturnsOnCall map[int]struct {
		result1 ccv2.ServiceInstanceSharedFrom
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstanceSharedTosStub        func(string) ([]ccv2.ServiceInstanceSharedTo, ccv2.Warnings, error)
	getServiceInstanceSharedTosMutex       sync.RWMutex
	getServiceInstanceSharedTosArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceSharedTosReturns struct {
		result1 []ccv2.ServiceInstanceSharedTo
		result2 ccv2.Warnings
		result3 error
	}
	getServiceInstanceSharedTosReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceInstanceSharedTo
		result2 ccv2.Warnings
		result3 error
	}
	GetServiceInstancesStub        func(...ccv2.Filter) ([]ccv2.ServiceInstance, ccv2.Warnings, error)
	getServiceInstancesMutex       sync.RWMutex
	getServiceInstancesArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getServiceInstancesReturns struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	getServiceInstancesReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetServicePlanStub        func(string) (ccv2.ServicePlan, ccv2.Warnings, error)
	getServicePlanMutex       sync.RWMutex
	getServicePlanArgsForCall []struct {
		arg1 string
	}
	getServicePlanReturns struct {
		result1 ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}
	getServicePlanReturnsOnCall map[int]struct {
		result1 ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}
	GetServicePlanVisibilitiesStub        func(...ccv2.Filter) ([]ccv2.ServicePlanVisibility, ccv2.Warnings, error)
	getServicePlanVisibilitiesMutex       sync.RWMutex
	getServicePlanVisibilitiesArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getServicePlanVisibilitiesReturns struct {
		result1 []ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}
	getServicePlanVisibilitiesReturnsOnCall map[int]struct {
		result1 []ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}
	GetServicePlansStub        func(...ccv2.Filter) ([]ccv2.ServicePlan, ccv2.Warnings, error)
	getServicePlansMutex       sync.RWMutex
	getServicePlansArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getServicePlansReturns struct {
		result1 []ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}
	getServicePlansReturnsOnCall map[int]struct {
		result1 []ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}
	GetServicesStub        func(...ccv2.Filter) ([]ccv2.Service, ccv2.Warnings, error)
	getServicesMutex       sync.RWMutex
	getServicesArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getServicesReturns struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}
	getServicesReturnsOnCall map[int]struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}
	GetSharedDomainStub        func(string) (ccv2.Domain, ccv2.Warnings, error)
	getSharedDomainMutex       sync.RWMutex
	getSharedDomainArgsForCall []struct {
		arg1 string
	}
	getSharedDomainReturns struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	getSharedDomainReturnsOnCall map[int]struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetSharedDomainsStub        func(...ccv2.Filter) ([]ccv2.Domain, ccv2.Warnings, error)
	getSharedDomainsMutex       sync.RWMutex
	getSharedDomainsArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getSharedDomainsReturns struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	getSharedDomainsReturnsOnCall map[int]struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceQuotaDefinitionStub        func(string) (ccv2.SpaceQuota, ccv2.Warnings, error)
	getSpaceQuotaDefinitionMutex       sync.RWMutex
	getSpaceQuotaDefinitionArgsForCall []struct {
		arg1 string
	}
	getSpaceQuotaDefinitionReturns struct {
		result1 ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceQuotaDefinitionReturnsOnCall map[int]struct {
		result1 ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceQuotasStub        func(string) ([]ccv2.SpaceQuota, ccv2.Warnings, error)
	getSpaceQuotasMutex       sync.RWMutex
	getSpaceQuotasArgsForCall []struct {
		arg1 string
	}
	getSpaceQuotasReturns struct {
		result1 []ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceQuotasReturnsOnCall map[int]struct {
		result1 []ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceRoutesStub        func(string, ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error)
	getSpaceRoutesMutex       sync.RWMutex
	getSpaceRoutesArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getSpaceRoutesReturns struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceRoutesReturnsOnCall map[int]struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceSecurityGroupsStub        func(string, ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error)
	getSpaceSecurityGroupsMutex       sync.RWMutex
	getSpaceSecurityGroupsArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getSpaceSecurityGroupsReturns struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceSecurityGroupsReturnsOnCall map[int]struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceServiceInstancesStub        func(string, bool, ...ccv2.Filter) ([]ccv2.ServiceInstance, ccv2.Warnings, error)
	getSpaceServiceInstancesMutex       sync.RWMutex
	getSpaceServiceInstancesArgsForCall []struct {
		arg1 string
		arg2 bool
		arg3 []ccv2.Filter
	}
	getSpaceServiceInstancesReturns struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceServiceInstancesReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceServicesStub        func(string, ...ccv2.Filter) ([]ccv2.Service, ccv2.Warnings, error)
	getSpaceServicesMutex       sync.RWMutex
	getSpaceServicesArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getSpaceServicesReturns struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceServicesReturnsOnCall map[int]struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}
	GetSpaceStagingSecurityGroupsStub        func(string, ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error)
	getSpaceStagingSecurityGroupsMutex       sync.RWMutex
	getSpaceStagingSecurityGroupsArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Filter
	}
	getSpaceStagingSecurityGroupsReturns struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	getSpaceStagingSecurityGroupsReturnsOnCall map[int]struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}
	GetSpacesStub        func(...ccv2.Filter) ([]ccv2.Space, ccv2.Warnings, error)
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getSpacesReturns struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	getSpacesReturnsOnCall map[int]struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}
	GetStackStub        func(string) (ccv2.Stack, ccv2.Warnings, error)
	getStackMutex       sync.RWMutex
	getStackArgsForCall []struct {
		arg1 string
	}
	getStackReturns struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	getStackReturnsOnCall map[int]struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	GetStacksStub        func(...ccv2.Filter) ([]ccv2.Stack, ccv2.Warnings, error)
	getStacksMutex       sync.RWMutex
	getStacksArgsForCall []struct {
		arg1 []ccv2.Filter
	}
	getStacksReturns struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	getStacksReturnsOnCall map[int]struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}
	GetUserProvidedServiceInstanceServiceBindingsStub        func(string) ([]ccv2.ServiceBinding, ccv2.Warnings, error)
	getUserProvidedServiceInstanceServiceBindingsMutex       sync.RWMutex
	getUserProvidedServiceInstanceServiceBindingsArgsForCall []struct {
		arg1 string
	}
	getUserProvidedServiceInstanceServiceBindingsReturns struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	getUserProvidedServiceInstanceServiceBindingsReturnsOnCall map[int]struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}
	MinCLIVersionStub        func() string
	minCLIVersionMutex       sync.RWMutex
	minCLIVersionArgsForCall []struct {
	}
	minCLIVersionReturns struct {
		result1 string
	}
	minCLIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	PollJobStub        func(ccv2.Job) (ccv2.Warnings, error)
	pollJobMutex       sync.RWMutex
	pollJobArgsForCall []struct {
		arg1 ccv2.Job
	}
	pollJobReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	pollJobReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	RestageApplicationStub        func(ccv2.Application) (ccv2.Application, ccv2.Warnings, error)
	restageApplicationMutex       sync.RWMutex
	restageApplicationArgsForCall []struct {
		arg1 ccv2.Application
	}
	restageApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	restageApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	RoutingEndpointStub        func() string
	routingEndpointMutex       sync.RWMutex
	routingEndpointArgsForCall []struct {
	}
	routingEndpointReturns struct {
		result1 string
	}
	routingEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	SetSpaceQuotaStub        func(string, string) (ccv2.Warnings, error)
	setSpaceQuotaMutex       sync.RWMutex
	setSpaceQuotaArgsForCall []struct {
		arg1 string
		arg2 string
	}
	setSpaceQuotaReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	setSpaceQuotaReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	TargetCFStub        func(ccv2.TargetSettings) (ccv2.Warnings, error)
	targetCFMutex       sync.RWMutex
	targetCFArgsForCall []struct {
		arg1 ccv2.TargetSettings
	}
	targetCFReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	targetCFReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	TokenEndpointStub        func() string
	tokenEndpointMutex       sync.RWMutex
	tokenEndpointArgsForCall []struct {
	}
	tokenEndpointReturns struct {
		result1 string
	}
	tokenEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	UpdateApplicationStub        func(ccv2.Application) (ccv2.Application, ccv2.Warnings, error)
	updateApplicationMutex       sync.RWMutex
	updateApplicationArgsForCall []struct {
		arg1 ccv2.Application
	}
	updateApplicationReturns struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	updateApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}
	UpdateBuildpackStub        func(ccv2.Buildpack) (ccv2.Buildpack, ccv2.Warnings, error)
	updateBuildpackMutex       sync.RWMutex
	updateBuildpackArgsForCall []struct {
		arg1 ccv2.Buildpack
	}
	updateBuildpackReturns struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}
	updateBuildpackReturnsOnCall map[int]struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}
	UpdateOrganizationManagerStub        func(string, string) (ccv2.Warnings, error)
	updateOrganizationManagerMutex       sync.RWMutex
	updateOrganizationManagerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateOrganizationManagerReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateOrganizationManagerReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateOrganizationManagerByUsernameStub        func(string, string) (ccv2.Warnings, error)
	updateOrganizationManagerByUsernameMutex       sync.RWMutex
	updateOrganizationManagerByUsernameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateOrganizationManagerByUsernameReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateOrganizationManagerByUsernameReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateOrganizationUserStub        func(string, string) (ccv2.Warnings, error)
	updateOrganizationUserMutex       sync.RWMutex
	updateOrganizationUserArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateOrganizationUserReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateOrganizationUserReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateOrganizationUserByUsernameStub        func(string, string) (ccv2.Warnings, error)
	updateOrganizationUserByUsernameMutex       sync.RWMutex
	updateOrganizationUserByUsernameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateOrganizationUserByUsernameReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateOrganizationUserByUsernameReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateResourceMatchStub        func([]ccv2.Resource) ([]ccv2.Resource, ccv2.Warnings, error)
	updateResourceMatchMutex       sync.RWMutex
	updateResourceMatchArgsForCall []struct {
		arg1 []ccv2.Resource
	}
	updateResourceMatchReturns struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}
	updateResourceMatchReturnsOnCall map[int]struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}
	UpdateRouteApplicationStub        func(string, string) (ccv2.Route, ccv2.Warnings, error)
	updateRouteApplicationMutex       sync.RWMutex
	updateRouteApplicationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateRouteApplicationReturns struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	updateRouteApplicationReturnsOnCall map[int]struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}
	UpdateSecurityGroupSpaceStub        func(string, string) (ccv2.Warnings, error)
	updateSecurityGroupSpaceMutex       sync.RWMutex
	updateSecurityGroupSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSecurityGroupSpaceReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateSecurityGroupSpaceReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateSecurityGroupStagingSpaceStub        func(string, string) (ccv2.Warnings, error)
	updateSecurityGroupStagingSpaceMutex       sync.RWMutex
	updateSecurityGroupStagingSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSecurityGroupStagingSpaceReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateSecurityGroupStagingSpaceReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateServicePlanStub        func(string, bool) (ccv2.Warnings, error)
	updateServicePlanMutex       sync.RWMutex
	updateServicePlanArgsForCall []struct {
		arg1 string
		arg2 bool
	}
	updateServicePlanReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateServicePlanReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateSpaceDeveloperStub        func(string, string) (ccv2.Warnings, error)
	updateSpaceDeveloperMutex       sync.RWMutex
	updateSpaceDeveloperArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSpaceDeveloperReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateSpaceDeveloperReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateSpaceDeveloperByUsernameStub        func(string, string) (ccv2.Warnings, error)
	updateSpaceDeveloperByUsernameMutex       sync.RWMutex
	updateSpaceDeveloperByUsernameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSpaceDeveloperByUsernameReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateSpaceDeveloperByUsernameReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateSpaceManagerStub        func(string, string) (ccv2.Warnings, error)
	updateSpaceManagerMutex       sync.RWMutex
	updateSpaceManagerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSpaceManagerReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateSpaceManagerReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UpdateSpaceManagerByUsernameStub        func(string, string) (ccv2.Warnings, error)
	updateSpaceManagerByUsernameMutex       sync.RWMutex
	updateSpaceManagerByUsernameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSpaceManagerByUsernameReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	updateSpaceManagerByUsernameReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UploadApplicationPackageStub        func(string, []ccv2.Resource, ccv2.Reader, int64) (ccv2.Job, ccv2.Warnings, error)
	uploadApplicationPackageMutex       sync.RWMutex
	uploadApplicationPackageArgsForCall []struct {
		arg1 string
		arg2 []ccv2.Resource
		arg3 ccv2.Reader
		arg4 int64
	}
	uploadApplicationPackageReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	uploadApplicationPackageReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	UploadBuildpackStub        func(string, string, io.Reader, int64) (ccv2.Warnings, error)
	uploadBuildpackMutex       sync.RWMutex
	uploadBuildpackArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}
	uploadBuildpackReturns struct {
		result1 ccv2.Warnings
		result2 error
	}
	uploadBuildpackReturnsOnCall map[int]struct {
		result1 ccv2.Warnings
		result2 error
	}
	UploadDropletStub        func(string, io.Reader, int64) (ccv2.Job, ccv2.Warnings, error)
	uploadDropletMutex       sync.RWMutex
	uploadDropletArgsForCall []struct {
		arg1 string
		arg2 io.Reader
		arg3 int64
	}
	uploadDropletReturns struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	uploadDropletReturnsOnCall map[int]struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCloudControllerClient) API() string {
	fake.aPIMutex.Lock()
	ret, specificReturn := fake.aPIReturnsOnCall[len(fake.aPIArgsForCall)]
	fake.aPIArgsForCall = append(fake.aPIArgsForCall, struct {
	}{})
	fake.recordInvocation("API", []interface{}{})
	fake.aPIMutex.Unlock()
	if fake.APIStub != nil {
		return fake.APIStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.aPIReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) APICallCount() int {
	fake.aPIMutex.RLock()
	defer fake.aPIMutex.RUnlock()
	return len(fake.aPIArgsForCall)
}

func (fake *FakeCloudControllerClient) APICalls(stub func() string) {
	fake.aPIMutex.Lock()
	defer fake.aPIMutex.Unlock()
	fake.APIStub = stub
}

func (fake *FakeCloudControllerClient) APIReturns(result1 string) {
	fake.aPIMutex.Lock()
	defer fake.aPIMutex.Unlock()
	fake.APIStub = nil
	fake.aPIReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) APIReturnsOnCall(i int, result1 string) {
	fake.aPIMutex.Lock()
	defer fake.aPIMutex.Unlock()
	fake.APIStub = nil
	if fake.aPIReturnsOnCall == nil {
		fake.aPIReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.aPIReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

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

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

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

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

func (fake *FakeCloudControllerClient) 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 *FakeCloudControllerClient) AuthorizationEndpoint() string {
	fake.authorizationEndpointMutex.Lock()
	ret, specificReturn := fake.authorizationEndpointReturnsOnCall[len(fake.authorizationEndpointArgsForCall)]
	fake.authorizationEndpointArgsForCall = append(fake.authorizationEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("AuthorizationEndpoint", []interface{}{})
	fake.authorizationEndpointMutex.Unlock()
	if fake.AuthorizationEndpointStub != nil {
		return fake.AuthorizationEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.authorizationEndpointReturns
	return fakeReturns.result1
}

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

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

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

func (fake *FakeCloudControllerClient) 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 *FakeCloudControllerClient) CheckRoute(arg1 ccv2.Route) (bool, ccv2.Warnings, error) {
	fake.checkRouteMutex.Lock()
	ret, specificReturn := fake.checkRouteReturnsOnCall[len(fake.checkRouteArgsForCall)]
	fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, struct {
		arg1 ccv2.Route
	}{arg1})
	fake.recordInvocation("CheckRoute", []interface{}{arg1})
	fake.checkRouteMutex.Unlock()
	if fake.CheckRouteStub != nil {
		return fake.CheckRouteStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.checkRouteReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CheckRouteCallCount() int {
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	return len(fake.checkRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) CheckRouteCalls(stub func(ccv2.Route) (bool, ccv2.Warnings, error)) {
	fake.checkRouteMutex.Lock()
	defer fake.checkRouteMutex.Unlock()
	fake.CheckRouteStub = stub
}

func (fake *FakeCloudControllerClient) CheckRouteArgsForCall(i int) ccv2.Route {
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	argsForCall := fake.checkRouteArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CheckRouteReturns(result1 bool, result2 ccv2.Warnings, result3 error) {
	fake.checkRouteMutex.Lock()
	defer fake.checkRouteMutex.Unlock()
	fake.CheckRouteStub = nil
	fake.checkRouteReturns = struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CheckRouteReturnsOnCall(i int, result1 bool, result2 ccv2.Warnings, result3 error) {
	fake.checkRouteMutex.Lock()
	defer fake.checkRouteMutex.Unlock()
	fake.CheckRouteStub = nil
	if fake.checkRouteReturnsOnCall == nil {
		fake.checkRouteReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.checkRouteReturnsOnCall[i] = struct {
		result1 bool
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplication(arg1 ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.createApplicationMutex.Lock()
	ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)]
	fake.createApplicationArgsForCall = append(fake.createApplicationArgsForCall, struct {
		arg1 ccv2.Application
	}{arg1})
	fake.recordInvocation("CreateApplication", []interface{}{arg1})
	fake.createApplicationMutex.Unlock()
	if fake.CreateApplicationStub != nil {
		return fake.CreateApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationCallCount() int {
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	return len(fake.createApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationCalls(stub func(ccv2.Application) (ccv2.Application, ccv2.Warnings, error)) {
	fake.createApplicationMutex.Lock()
	defer fake.createApplicationMutex.Unlock()
	fake.CreateApplicationStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationArgsForCall(i int) ccv2.Application {
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	argsForCall := fake.createApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.createApplicationMutex.Lock()
	defer fake.createApplicationMutex.Unlock()
	fake.CreateApplicationStub = nil
	fake.createApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.createApplicationMutex.Lock()
	defer fake.createApplicationMutex.Unlock()
	fake.CreateApplicationStub = nil
	if fake.createApplicationReturnsOnCall == nil {
		fake.createApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildpack(arg1 ccv2.Buildpack) (ccv2.Buildpack, ccv2.Warnings, error) {
	fake.createBuildpackMutex.Lock()
	ret, specificReturn := fake.createBuildpackReturnsOnCall[len(fake.createBuildpackArgsForCall)]
	fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, struct {
		arg1 ccv2.Buildpack
	}{arg1})
	fake.recordInvocation("CreateBuildpack", []interface{}{arg1})
	fake.createBuildpackMutex.Unlock()
	if fake.CreateBuildpackStub != nil {
		return fake.CreateBuildpackStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createBuildpackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateBuildpackCallCount() int {
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	return len(fake.createBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateBuildpackCalls(stub func(ccv2.Buildpack) (ccv2.Buildpack, ccv2.Warnings, error)) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) CreateBuildpackArgsForCall(i int) ccv2.Buildpack {
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	argsForCall := fake.createBuildpackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateBuildpackReturns(result1 ccv2.Buildpack, result2 ccv2.Warnings, result3 error) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = nil
	fake.createBuildpackReturns = struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildpackReturnsOnCall(i int, result1 ccv2.Buildpack, result2 ccv2.Warnings, result3 error) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = nil
	if fake.createBuildpackReturnsOnCall == nil {
		fake.createBuildpackReturnsOnCall = make(map[int]struct {
			result1 ccv2.Buildpack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createBuildpackReturnsOnCall[i] = struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateOrganization(arg1 string, arg2 string) (ccv2.Organization, ccv2.Warnings, error) {
	fake.createOrganizationMutex.Lock()
	ret, specificReturn := fake.createOrganizationReturnsOnCall[len(fake.createOrganizationArgsForCall)]
	fake.createOrganizationArgsForCall = append(fake.createOrganizationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateOrganization", []interface{}{arg1, arg2})
	fake.createOrganizationMutex.Unlock()
	if fake.CreateOrganizationStub != nil {
		return fake.CreateOrganizationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateOrganizationCallCount() int {
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	return len(fake.createOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateOrganizationCalls(stub func(string, string) (ccv2.Organization, ccv2.Warnings, error)) {
	fake.createOrganizationMutex.Lock()
	defer fake.createOrganizationMutex.Unlock()
	fake.CreateOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) CreateOrganizationArgsForCall(i int) (string, string) {
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	argsForCall := fake.createOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateOrganizationReturns(result1 ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.createOrganizationMutex.Lock()
	defer fake.createOrganizationMutex.Unlock()
	fake.CreateOrganizationStub = nil
	fake.createOrganizationReturns = struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateOrganizationReturnsOnCall(i int, result1 ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.createOrganizationMutex.Lock()
	defer fake.createOrganizationMutex.Unlock()
	fake.CreateOrganizationStub = nil
	if fake.createOrganizationReturnsOnCall == nil {
		fake.createOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Organization
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createOrganizationReturnsOnCall[i] = struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRoute(arg1 ccv2.Route, arg2 bool) (ccv2.Route, ccv2.Warnings, error) {
	fake.createRouteMutex.Lock()
	ret, specificReturn := fake.createRouteReturnsOnCall[len(fake.createRouteArgsForCall)]
	fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, struct {
		arg1 ccv2.Route
		arg2 bool
	}{arg1, arg2})
	fake.recordInvocation("CreateRoute", []interface{}{arg1, arg2})
	fake.createRouteMutex.Unlock()
	if fake.CreateRouteStub != nil {
		return fake.CreateRouteStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createRouteReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateRouteCallCount() int {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	return len(fake.createRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateRouteCalls(stub func(ccv2.Route, bool) (ccv2.Route, ccv2.Warnings, error)) {
	fake.createRouteMutex.Lock()
	defer fake.createRouteMutex.Unlock()
	fake.CreateRouteStub = stub
}

func (fake *FakeCloudControllerClient) CreateRouteArgsForCall(i int) (ccv2.Route, bool) {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	argsForCall := fake.createRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateRouteReturns(result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.createRouteMutex.Lock()
	defer fake.createRouteMutex.Unlock()
	fake.CreateRouteStub = nil
	fake.createRouteReturns = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateRouteReturnsOnCall(i int, result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.createRouteMutex.Lock()
	defer fake.createRouteMutex.Unlock()
	fake.CreateRouteStub = nil
	if fake.createRouteReturnsOnCall == nil {
		fake.createRouteReturnsOnCall = make(map[int]struct {
			result1 ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createRouteReturnsOnCall[i] = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBinding(arg1 string, arg2 string, arg3 string, arg4 bool, arg5 map[string]interface{}) (ccv2.ServiceBinding, ccv2.Warnings, error) {
	fake.createServiceBindingMutex.Lock()
	ret, specificReturn := fake.createServiceBindingReturnsOnCall[len(fake.createServiceBindingArgsForCall)]
	fake.createServiceBindingArgsForCall = append(fake.createServiceBindingArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 bool
		arg5 map[string]interface{}
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("CreateServiceBinding", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.createServiceBindingMutex.Unlock()
	if fake.CreateServiceBindingStub != nil {
		return fake.CreateServiceBindingStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createServiceBindingReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceBindingCallCount() int {
	fake.createServiceBindingMutex.RLock()
	defer fake.createServiceBindingMutex.RUnlock()
	return len(fake.createServiceBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceBindingCalls(stub func(string, string, string, bool, map[string]interface{}) (ccv2.ServiceBinding, ccv2.Warnings, error)) {
	fake.createServiceBindingMutex.Lock()
	defer fake.createServiceBindingMutex.Unlock()
	fake.CreateServiceBindingStub = stub
}

func (fake *FakeCloudControllerClient) CreateServiceBindingArgsForCall(i int) (string, string, string, bool, map[string]interface{}) {
	fake.createServiceBindingMutex.RLock()
	defer fake.createServiceBindingMutex.RUnlock()
	argsForCall := fake.createServiceBindingArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeCloudControllerClient) CreateServiceBindingReturns(result1 ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.createServiceBindingMutex.Lock()
	defer fake.createServiceBindingMutex.Unlock()
	fake.CreateServiceBindingStub = nil
	fake.createServiceBindingReturns = struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBindingReturnsOnCall(i int, result1 ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.createServiceBindingMutex.Lock()
	defer fake.createServiceBindingMutex.Unlock()
	fake.CreateServiceBindingStub = nil
	if fake.createServiceBindingReturnsOnCall == nil {
		fake.createServiceBindingReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createServiceBindingReturnsOnCall[i] = struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBroker(arg1 string, arg2 string, arg3 string, arg4 string, arg5 string) (ccv2.ServiceBroker, ccv2.Warnings, error) {
	fake.createServiceBrokerMutex.Lock()
	ret, specificReturn := fake.createServiceBrokerReturnsOnCall[len(fake.createServiceBrokerArgsForCall)]
	fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 string
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("CreateServiceBroker", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.createServiceBrokerMutex.Unlock()
	if fake.CreateServiceBrokerStub != nil {
		return fake.CreateServiceBrokerStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createServiceBrokerReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerCallCount() int {
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	return len(fake.createServiceBrokerArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerCalls(stub func(string, string, string, string, string) (ccv2.ServiceBroker, ccv2.Warnings, error)) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = stub
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerArgsForCall(i int) (string, string, string, string, string) {
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	argsForCall := fake.createServiceBrokerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerReturns(result1 ccv2.ServiceBroker, result2 ccv2.Warnings, result3 error) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = nil
	fake.createServiceBrokerReturns = struct {
		result1 ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceBrokerReturnsOnCall(i int, result1 ccv2.ServiceBroker, result2 ccv2.Warnings, result3 error) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = nil
	if fake.createServiceBrokerReturnsOnCall == nil {
		fake.createServiceBrokerReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceBroker
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createServiceBrokerReturnsOnCall[i] = struct {
		result1 ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceKey(arg1 string, arg2 string, arg3 map[string]interface{}) (ccv2.ServiceKey, ccv2.Warnings, error) {
	fake.createServiceKeyMutex.Lock()
	ret, specificReturn := fake.createServiceKeyReturnsOnCall[len(fake.createServiceKeyArgsForCall)]
	fake.createServiceKeyArgsForCall = append(fake.createServiceKeyArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]interface{}
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateServiceKey", []interface{}{arg1, arg2, arg3})
	fake.createServiceKeyMutex.Unlock()
	if fake.CreateServiceKeyStub != nil {
		return fake.CreateServiceKeyStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createServiceKeyReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServiceKeyCallCount() int {
	fake.createServiceKeyMutex.RLock()
	defer fake.createServiceKeyMutex.RUnlock()
	return len(fake.createServiceKeyArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServiceKeyCalls(stub func(string, string, map[string]interface{}) (ccv2.ServiceKey, ccv2.Warnings, error)) {
	fake.createServiceKeyMutex.Lock()
	defer fake.createServiceKeyMutex.Unlock()
	fake.CreateServiceKeyStub = stub
}

func (fake *FakeCloudControllerClient) CreateServiceKeyArgsForCall(i int) (string, string, map[string]interface{}) {
	fake.createServiceKeyMutex.RLock()
	defer fake.createServiceKeyMutex.RUnlock()
	argsForCall := fake.createServiceKeyArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) CreateServiceKeyReturns(result1 ccv2.ServiceKey, result2 ccv2.Warnings, result3 error) {
	fake.createServiceKeyMutex.Lock()
	defer fake.createServiceKeyMutex.Unlock()
	fake.CreateServiceKeyStub = nil
	fake.createServiceKeyReturns = struct {
		result1 ccv2.ServiceKey
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServiceKeyReturnsOnCall(i int, result1 ccv2.ServiceKey, result2 ccv2.Warnings, result3 error) {
	fake.createServiceKeyMutex.Lock()
	defer fake.createServiceKeyMutex.Unlock()
	fake.CreateServiceKeyStub = nil
	if fake.createServiceKeyReturnsOnCall == nil {
		fake.createServiceKeyReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceKey
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createServiceKeyReturnsOnCall[i] = struct {
		result1 ccv2.ServiceKey
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServicePlanVisibility(arg1 string, arg2 string) (ccv2.ServicePlanVisibility, ccv2.Warnings, error) {
	fake.createServicePlanVisibilityMutex.Lock()
	ret, specificReturn := fake.createServicePlanVisibilityReturnsOnCall[len(fake.createServicePlanVisibilityArgsForCall)]
	fake.createServicePlanVisibilityArgsForCall = append(fake.createServicePlanVisibilityArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateServicePlanVisibility", []interface{}{arg1, arg2})
	fake.createServicePlanVisibilityMutex.Unlock()
	if fake.CreateServicePlanVisibilityStub != nil {
		return fake.CreateServicePlanVisibilityStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createServicePlanVisibilityReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateServicePlanVisibilityCallCount() int {
	fake.createServicePlanVisibilityMutex.RLock()
	defer fake.createServicePlanVisibilityMutex.RUnlock()
	return len(fake.createServicePlanVisibilityArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateServicePlanVisibilityCalls(stub func(string, string) (ccv2.ServicePlanVisibility, ccv2.Warnings, error)) {
	fake.createServicePlanVisibilityMutex.Lock()
	defer fake.createServicePlanVisibilityMutex.Unlock()
	fake.CreateServicePlanVisibilityStub = stub
}

func (fake *FakeCloudControllerClient) CreateServicePlanVisibilityArgsForCall(i int) (string, string) {
	fake.createServicePlanVisibilityMutex.RLock()
	defer fake.createServicePlanVisibilityMutex.RUnlock()
	argsForCall := fake.createServicePlanVisibilityArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateServicePlanVisibilityReturns(result1 ccv2.ServicePlanVisibility, result2 ccv2.Warnings, result3 error) {
	fake.createServicePlanVisibilityMutex.Lock()
	defer fake.createServicePlanVisibilityMutex.Unlock()
	fake.CreateServicePlanVisibilityStub = nil
	fake.createServicePlanVisibilityReturns = struct {
		result1 ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateServicePlanVisibilityReturnsOnCall(i int, result1 ccv2.ServicePlanVisibility, result2 ccv2.Warnings, result3 error) {
	fake.createServicePlanVisibilityMutex.Lock()
	defer fake.createServicePlanVisibilityMutex.Unlock()
	fake.CreateServicePlanVisibilityStub = nil
	if fake.createServicePlanVisibilityReturnsOnCall == nil {
		fake.createServicePlanVisibilityReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServicePlanVisibility
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createServicePlanVisibilityReturnsOnCall[i] = struct {
		result1 ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSharedDomain(arg1 string, arg2 string, arg3 bool) (ccv2.Warnings, error) {
	fake.createSharedDomainMutex.Lock()
	ret, specificReturn := fake.createSharedDomainReturnsOnCall[len(fake.createSharedDomainArgsForCall)]
	fake.createSharedDomainArgsForCall = append(fake.createSharedDomainArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateSharedDomain", []interface{}{arg1, arg2, arg3})
	fake.createSharedDomainMutex.Unlock()
	if fake.CreateSharedDomainStub != nil {
		return fake.CreateSharedDomainStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createSharedDomainReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) CreateSharedDomainCallCount() int {
	fake.createSharedDomainMutex.RLock()
	defer fake.createSharedDomainMutex.RUnlock()
	return len(fake.createSharedDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateSharedDomainCalls(stub func(string, string, bool) (ccv2.Warnings, error)) {
	fake.createSharedDomainMutex.Lock()
	defer fake.createSharedDomainMutex.Unlock()
	fake.CreateSharedDomainStub = stub
}

func (fake *FakeCloudControllerClient) CreateSharedDomainArgsForCall(i int) (string, string, bool) {
	fake.createSharedDomainMutex.RLock()
	defer fake.createSharedDomainMutex.RUnlock()
	argsForCall := fake.createSharedDomainArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) CreateSharedDomainReturns(result1 ccv2.Warnings, result2 error) {
	fake.createSharedDomainMutex.Lock()
	defer fake.createSharedDomainMutex.Unlock()
	fake.CreateSharedDomainStub = nil
	fake.createSharedDomainReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) CreateSharedDomainReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.createSharedDomainMutex.Lock()
	defer fake.createSharedDomainMutex.Unlock()
	fake.CreateSharedDomainStub = nil
	if fake.createSharedDomainReturnsOnCall == nil {
		fake.createSharedDomainReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.createSharedDomainReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) CreateSpace(arg1 string, arg2 string) (ccv2.Space, ccv2.Warnings, error) {
	fake.createSpaceMutex.Lock()
	ret, specificReturn := fake.createSpaceReturnsOnCall[len(fake.createSpaceArgsForCall)]
	fake.createSpaceArgsForCall = append(fake.createSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateSpace", []interface{}{arg1, arg2})
	fake.createSpaceMutex.Unlock()
	if fake.CreateSpaceStub != nil {
		return fake.CreateSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateSpaceCallCount() int {
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	return len(fake.createSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateSpaceCalls(stub func(string, string) (ccv2.Space, ccv2.Warnings, error)) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = stub
}

func (fake *FakeCloudControllerClient) CreateSpaceArgsForCall(i int) (string, string) {
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	argsForCall := fake.createSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateSpaceReturns(result1 ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = nil
	fake.createSpaceReturns = struct {
		result1 ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateSpaceReturnsOnCall(i int, result1 ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.createSpaceMutex.Lock()
	defer fake.createSpaceMutex.Unlock()
	fake.CreateSpaceStub = nil
	if fake.createSpaceReturnsOnCall == nil {
		fake.createSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createSpaceReturnsOnCall[i] = struct {
		result1 ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateUser(arg1 string) (ccv2.User, ccv2.Warnings, error) {
	fake.createUserMutex.Lock()
	ret, specificReturn := fake.createUserReturnsOnCall[len(fake.createUserArgsForCall)]
	fake.createUserArgsForCall = append(fake.createUserArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("CreateUser", []interface{}{arg1})
	fake.createUserMutex.Unlock()
	if fake.CreateUserStub != nil {
		return fake.CreateUserStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createUserReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateUserCallCount() int {
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	return len(fake.createUserArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateUserCalls(stub func(string) (ccv2.User, ccv2.Warnings, error)) {
	fake.createUserMutex.Lock()
	defer fake.createUserMutex.Unlock()
	fake.CreateUserStub = stub
}

func (fake *FakeCloudControllerClient) CreateUserArgsForCall(i int) string {
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	argsForCall := fake.createUserArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateUserReturns(result1 ccv2.User, result2 ccv2.Warnings, result3 error) {
	fake.createUserMutex.Lock()
	defer fake.createUserMutex.Unlock()
	fake.CreateUserStub = nil
	fake.createUserReturns = struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateUserReturnsOnCall(i int, result1 ccv2.User, result2 ccv2.Warnings, result3 error) {
	fake.createUserMutex.Lock()
	defer fake.createUserMutex.Unlock()
	fake.CreateUserStub = nil
	if fake.createUserReturnsOnCall == nil {
		fake.createUserReturnsOnCall = make(map[int]struct {
			result1 ccv2.User
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.createUserReturnsOnCall[i] = struct {
		result1 ccv2.User
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrganizationJob(arg1 string) (ccv2.Job, ccv2.Warnings, error) {
	fake.deleteOrganizationJobMutex.Lock()
	ret, specificReturn := fake.deleteOrganizationJobReturnsOnCall[len(fake.deleteOrganizationJobArgsForCall)]
	fake.deleteOrganizationJobArgsForCall = append(fake.deleteOrganizationJobArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteOrganizationJob", []interface{}{arg1})
	fake.deleteOrganizationJobMutex.Unlock()
	if fake.DeleteOrganizationJobStub != nil {
		return fake.DeleteOrganizationJobStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteOrganizationJobReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteOrganizationJobCallCount() int {
	fake.deleteOrganizationJobMutex.RLock()
	defer fake.deleteOrganizationJobMutex.RUnlock()
	return len(fake.deleteOrganizationJobArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteOrganizationJobCalls(stub func(string) (ccv2.Job, ccv2.Warnings, error)) {
	fake.deleteOrganizationJobMutex.Lock()
	defer fake.deleteOrganizationJobMutex.Unlock()
	fake.DeleteOrganizationJobStub = stub
}

func (fake *FakeCloudControllerClient) DeleteOrganizationJobArgsForCall(i int) string {
	fake.deleteOrganizationJobMutex.RLock()
	defer fake.deleteOrganizationJobMutex.RUnlock()
	argsForCall := fake.deleteOrganizationJobArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteOrganizationJobReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.deleteOrganizationJobMutex.Lock()
	defer fake.deleteOrganizationJobMutex.Unlock()
	fake.DeleteOrganizationJobStub = nil
	fake.deleteOrganizationJobReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteOrganizationJobReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.deleteOrganizationJobMutex.Lock()
	defer fake.deleteOrganizationJobMutex.Unlock()
	fake.DeleteOrganizationJobStub = nil
	if fake.deleteOrganizationJobReturnsOnCall == nil {
		fake.deleteOrganizationJobReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.deleteOrganizationJobReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteRoute(arg1 string) (ccv2.Warnings, error) {
	fake.deleteRouteMutex.Lock()
	ret, specificReturn := fake.deleteRouteReturnsOnCall[len(fake.deleteRouteArgsForCall)]
	fake.deleteRouteArgsForCall = append(fake.deleteRouteArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteRoute", []interface{}{arg1})
	fake.deleteRouteMutex.Unlock()
	if fake.DeleteRouteStub != nil {
		return fake.DeleteRouteStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteRouteCallCount() int {
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	return len(fake.deleteRouteArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteRouteCalls(stub func(string) (ccv2.Warnings, error)) {
	fake.deleteRouteMutex.Lock()
	defer fake.deleteRouteMutex.Unlock()
	fake.DeleteRouteStub = stub
}

func (fake *FakeCloudControllerClient) DeleteRouteArgsForCall(i int) string {
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	argsForCall := fake.deleteRouteArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteRouteReturns(result1 ccv2.Warnings, result2 error) {
	fake.deleteRouteMutex.Lock()
	defer fake.deleteRouteMutex.Unlock()
	fake.DeleteRouteStub = nil
	fake.deleteRouteReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteRouteReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.deleteRouteMutex.Lock()
	defer fake.deleteRouteMutex.Unlock()
	fake.DeleteRouteStub = nil
	if fake.deleteRouteReturnsOnCall == nil {
		fake.deleteRouteReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteRouteReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteRouteApplication(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.deleteRouteApplicationMutex.Lock()
	ret, specificReturn := fake.deleteRouteApplicationReturnsOnCall[len(fake.deleteRouteApplicationArgsForCall)]
	fake.deleteRouteApplicationArgsForCall = append(fake.deleteRouteApplicationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteRouteApplication", []interface{}{arg1, arg2})
	fake.deleteRouteApplicationMutex.Unlock()
	if fake.DeleteRouteApplicationStub != nil {
		return fake.DeleteRouteApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteRouteApplicationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteRouteApplicationCallCount() int {
	fake.deleteRouteApplicationMutex.RLock()
	defer fake.deleteRouteApplicationMutex.RUnlock()
	return len(fake.deleteRouteApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteRouteApplicationCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.deleteRouteApplicationMutex.Lock()
	defer fake.deleteRouteApplicationMutex.Unlock()
	fake.DeleteRouteApplicationStub = stub
}

func (fake *FakeCloudControllerClient) DeleteRouteApplicationArgsForCall(i int) (string, string) {
	fake.deleteRouteApplicationMutex.RLock()
	defer fake.deleteRouteApplicationMutex.RUnlock()
	argsForCall := fake.deleteRouteApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteRouteApplicationReturns(result1 ccv2.Warnings, result2 error) {
	fake.deleteRouteApplicationMutex.Lock()
	defer fake.deleteRouteApplicationMutex.Unlock()
	fake.DeleteRouteApplicationStub = nil
	fake.deleteRouteApplicationReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteRouteApplicationReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.deleteRouteApplicationMutex.Lock()
	defer fake.deleteRouteApplicationMutex.Unlock()
	fake.DeleteRouteApplicationStub = nil
	if fake.deleteRouteApplicationReturnsOnCall == nil {
		fake.deleteRouteApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteRouteApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupSpace(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.deleteSecurityGroupSpaceMutex.Lock()
	ret, specificReturn := fake.deleteSecurityGroupSpaceReturnsOnCall[len(fake.deleteSecurityGroupSpaceArgsForCall)]
	fake.deleteSecurityGroupSpaceArgsForCall = append(fake.deleteSecurityGroupSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteSecurityGroupSpace", []interface{}{arg1, arg2})
	fake.deleteSecurityGroupSpaceMutex.Unlock()
	if fake.DeleteSecurityGroupSpaceStub != nil {
		return fake.DeleteSecurityGroupSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteSecurityGroupSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupSpaceCallCount() int {
	fake.deleteSecurityGroupSpaceMutex.RLock()
	defer fake.deleteSecurityGroupSpaceMutex.RUnlock()
	return len(fake.deleteSecurityGroupSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupSpaceCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.deleteSecurityGroupSpaceMutex.Lock()
	defer fake.deleteSecurityGroupSpaceMutex.Unlock()
	fake.DeleteSecurityGroupSpaceStub = stub
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupSpaceArgsForCall(i int) (string, string) {
	fake.deleteSecurityGroupSpaceMutex.RLock()
	defer fake.deleteSecurityGroupSpaceMutex.RUnlock()
	argsForCall := fake.deleteSecurityGroupSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupSpaceReturns(result1 ccv2.Warnings, result2 error) {
	fake.deleteSecurityGroupSpaceMutex.Lock()
	defer fake.deleteSecurityGroupSpaceMutex.Unlock()
	fake.DeleteSecurityGroupSpaceStub = nil
	fake.deleteSecurityGroupSpaceReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupSpaceReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.deleteSecurityGroupSpaceMutex.Lock()
	defer fake.deleteSecurityGroupSpaceMutex.Unlock()
	fake.DeleteSecurityGroupSpaceStub = nil
	if fake.deleteSecurityGroupSpaceReturnsOnCall == nil {
		fake.deleteSecurityGroupSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteSecurityGroupSpaceReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupStagingSpace(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.deleteSecurityGroupStagingSpaceMutex.Lock()
	ret, specificReturn := fake.deleteSecurityGroupStagingSpaceReturnsOnCall[len(fake.deleteSecurityGroupStagingSpaceArgsForCall)]
	fake.deleteSecurityGroupStagingSpaceArgsForCall = append(fake.deleteSecurityGroupStagingSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteSecurityGroupStagingSpace", []interface{}{arg1, arg2})
	fake.deleteSecurityGroupStagingSpaceMutex.Unlock()
	if fake.DeleteSecurityGroupStagingSpaceStub != nil {
		return fake.DeleteSecurityGroupStagingSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteSecurityGroupStagingSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupStagingSpaceCallCount() int {
	fake.deleteSecurityGroupStagingSpaceMutex.RLock()
	defer fake.deleteSecurityGroupStagingSpaceMutex.RUnlock()
	return len(fake.deleteSecurityGroupStagingSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupStagingSpaceCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.deleteSecurityGroupStagingSpaceMutex.Lock()
	defer fake.deleteSecurityGroupStagingSpaceMutex.Unlock()
	fake.DeleteSecurityGroupStagingSpaceStub = stub
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupStagingSpaceArgsForCall(i int) (string, string) {
	fake.deleteSecurityGroupStagingSpaceMutex.RLock()
	defer fake.deleteSecurityGroupStagingSpaceMutex.RUnlock()
	argsForCall := fake.deleteSecurityGroupStagingSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupStagingSpaceReturns(result1 ccv2.Warnings, result2 error) {
	fake.deleteSecurityGroupStagingSpaceMutex.Lock()
	defer fake.deleteSecurityGroupStagingSpaceMutex.Unlock()
	fake.DeleteSecurityGroupStagingSpaceStub = nil
	fake.deleteSecurityGroupStagingSpaceReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteSecurityGroupStagingSpaceReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.deleteSecurityGroupStagingSpaceMutex.Lock()
	defer fake.deleteSecurityGroupStagingSpaceMutex.Unlock()
	fake.DeleteSecurityGroupStagingSpaceStub = nil
	if fake.deleteSecurityGroupStagingSpaceReturnsOnCall == nil {
		fake.deleteSecurityGroupStagingSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteSecurityGroupStagingSpaceReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServiceBinding(arg1 string, arg2 bool) (ccv2.ServiceBinding, ccv2.Warnings, error) {
	fake.deleteServiceBindingMutex.Lock()
	ret, specificReturn := fake.deleteServiceBindingReturnsOnCall[len(fake.deleteServiceBindingArgsForCall)]
	fake.deleteServiceBindingArgsForCall = append(fake.deleteServiceBindingArgsForCall, struct {
		arg1 string
		arg2 bool
	}{arg1, arg2})
	fake.recordInvocation("DeleteServiceBinding", []interface{}{arg1, arg2})
	fake.deleteServiceBindingMutex.Unlock()
	if fake.DeleteServiceBindingStub != nil {
		return fake.DeleteServiceBindingStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteServiceBindingReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingCallCount() int {
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	return len(fake.deleteServiceBindingArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingCalls(stub func(string, bool) (ccv2.ServiceBinding, ccv2.Warnings, error)) {
	fake.deleteServiceBindingMutex.Lock()
	defer fake.deleteServiceBindingMutex.Unlock()
	fake.DeleteServiceBindingStub = stub
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingArgsForCall(i int) (string, bool) {
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	argsForCall := fake.deleteServiceBindingArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingReturns(result1 ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.deleteServiceBindingMutex.Lock()
	defer fake.deleteServiceBindingMutex.Unlock()
	fake.DeleteServiceBindingStub = nil
	fake.deleteServiceBindingReturns = struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServiceBindingReturnsOnCall(i int, result1 ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.deleteServiceBindingMutex.Lock()
	defer fake.deleteServiceBindingMutex.Unlock()
	fake.DeleteServiceBindingStub = nil
	if fake.deleteServiceBindingReturnsOnCall == nil {
		fake.deleteServiceBindingReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.deleteServiceBindingReturnsOnCall[i] = struct {
		result1 ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibility(arg1 string) (ccv2.Warnings, error) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	ret, specificReturn := fake.deleteServicePlanVisibilityReturnsOnCall[len(fake.deleteServicePlanVisibilityArgsForCall)]
	fake.deleteServicePlanVisibilityArgsForCall = append(fake.deleteServicePlanVisibilityArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteServicePlanVisibility", []interface{}{arg1})
	fake.deleteServicePlanVisibilityMutex.Unlock()
	if fake.DeleteServicePlanVisibilityStub != nil {
		return fake.DeleteServicePlanVisibilityStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteServicePlanVisibilityReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityCallCount() int {
	fake.deleteServicePlanVisibilityMutex.RLock()
	defer fake.deleteServicePlanVisibilityMutex.RUnlock()
	return len(fake.deleteServicePlanVisibilityArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityCalls(stub func(string) (ccv2.Warnings, error)) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	defer fake.deleteServicePlanVisibilityMutex.Unlock()
	fake.DeleteServicePlanVisibilityStub = stub
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityArgsForCall(i int) string {
	fake.deleteServicePlanVisibilityMutex.RLock()
	defer fake.deleteServicePlanVisibilityMutex.RUnlock()
	argsForCall := fake.deleteServicePlanVisibilityArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityReturns(result1 ccv2.Warnings, result2 error) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	defer fake.deleteServicePlanVisibilityMutex.Unlock()
	fake.DeleteServicePlanVisibilityStub = nil
	fake.deleteServicePlanVisibilityReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServicePlanVisibilityReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.deleteServicePlanVisibilityMutex.Lock()
	defer fake.deleteServicePlanVisibilityMutex.Unlock()
	fake.DeleteServicePlanVisibilityStub = nil
	if fake.deleteServicePlanVisibilityReturnsOnCall == nil {
		fake.deleteServicePlanVisibilityReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.deleteServicePlanVisibilityReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteSpaceJob(arg1 string) (ccv2.Job, ccv2.Warnings, error) {
	fake.deleteSpaceJobMutex.Lock()
	ret, specificReturn := fake.deleteSpaceJobReturnsOnCall[len(fake.deleteSpaceJobArgsForCall)]
	fake.deleteSpaceJobArgsForCall = append(fake.deleteSpaceJobArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteSpaceJob", []interface{}{arg1})
	fake.deleteSpaceJobMutex.Unlock()
	if fake.DeleteSpaceJobStub != nil {
		return fake.DeleteSpaceJobStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteSpaceJobReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteSpaceJobCallCount() int {
	fake.deleteSpaceJobMutex.RLock()
	defer fake.deleteSpaceJobMutex.RUnlock()
	return len(fake.deleteSpaceJobArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteSpaceJobCalls(stub func(string) (ccv2.Job, ccv2.Warnings, error)) {
	fake.deleteSpaceJobMutex.Lock()
	defer fake.deleteSpaceJobMutex.Unlock()
	fake.DeleteSpaceJobStub = stub
}

func (fake *FakeCloudControllerClient) DeleteSpaceJobArgsForCall(i int) string {
	fake.deleteSpaceJobMutex.RLock()
	defer fake.deleteSpaceJobMutex.RUnlock()
	argsForCall := fake.deleteSpaceJobArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteSpaceJobReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.deleteSpaceJobMutex.Lock()
	defer fake.deleteSpaceJobMutex.Unlock()
	fake.DeleteSpaceJobStub = nil
	fake.deleteSpaceJobReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteSpaceJobReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.deleteSpaceJobMutex.Lock()
	defer fake.deleteSpaceJobMutex.Unlock()
	fake.DeleteSpaceJobStub = nil
	if fake.deleteSpaceJobReturnsOnCall == nil {
		fake.deleteSpaceJobReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.deleteSpaceJobReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DopplerEndpoint() string {
	fake.dopplerEndpointMutex.Lock()
	ret, specificReturn := fake.dopplerEndpointReturnsOnCall[len(fake.dopplerEndpointArgsForCall)]
	fake.dopplerEndpointArgsForCall = append(fake.dopplerEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("DopplerEndpoint", []interface{}{})
	fake.dopplerEndpointMutex.Unlock()
	if fake.DopplerEndpointStub != nil {
		return fake.DopplerEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.dopplerEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) DopplerEndpointCallCount() int {
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	return len(fake.dopplerEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) DopplerEndpointCalls(stub func() string) {
	fake.dopplerEndpointMutex.Lock()
	defer fake.dopplerEndpointMutex.Unlock()
	fake.DopplerEndpointStub = stub
}

func (fake *FakeCloudControllerClient) DopplerEndpointReturns(result1 string) {
	fake.dopplerEndpointMutex.Lock()
	defer fake.dopplerEndpointMutex.Unlock()
	fake.DopplerEndpointStub = nil
	fake.dopplerEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) DopplerEndpointReturnsOnCall(i int, result1 string) {
	fake.dopplerEndpointMutex.Lock()
	defer fake.dopplerEndpointMutex.Unlock()
	fake.DopplerEndpointStub = nil
	if fake.dopplerEndpointReturnsOnCall == nil {
		fake.dopplerEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.dopplerEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) GetApplication(arg1 string) (ccv2.Application, ccv2.Warnings, error) {
	fake.getApplicationMutex.Lock()
	ret, specificReturn := fake.getApplicationReturnsOnCall[len(fake.getApplicationArgsForCall)]
	fake.getApplicationArgsForCall = append(fake.getApplicationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplication", []interface{}{arg1})
	fake.getApplicationMutex.Unlock()
	if fake.GetApplicationStub != nil {
		return fake.GetApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationCallCount() int {
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	return len(fake.getApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationCalls(stub func(string) (ccv2.Application, ccv2.Warnings, error)) {
	fake.getApplicationMutex.Lock()
	defer fake.getApplicationMutex.Unlock()
	fake.GetApplicationStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationArgsForCall(i int) string {
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	argsForCall := fake.getApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationMutex.Lock()
	defer fake.getApplicationMutex.Unlock()
	fake.GetApplicationStub = nil
	fake.getApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationMutex.Lock()
	defer fake.getApplicationMutex.Unlock()
	fake.GetApplicationStub = nil
	if fake.getApplicationReturnsOnCall == nil {
		fake.getApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstanceStatuses(arg1 string) (map[int]ccv2.ApplicationInstanceStatus, ccv2.Warnings, error) {
	fake.getApplicationApplicationInstanceStatusesMutex.Lock()
	ret, specificReturn := fake.getApplicationApplicationInstanceStatusesReturnsOnCall[len(fake.getApplicationApplicationInstanceStatusesArgsForCall)]
	fake.getApplicationApplicationInstanceStatusesArgsForCall = append(fake.getApplicationApplicationInstanceStatusesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationApplicationInstanceStatuses", []interface{}{arg1})
	fake.getApplicationApplicationInstanceStatusesMutex.Unlock()
	if fake.GetApplicationApplicationInstanceStatusesStub != nil {
		return fake.GetApplicationApplicationInstanceStatusesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationApplicationInstanceStatusesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstanceStatusesCallCount() int {
	fake.getApplicationApplicationInstanceStatusesMutex.RLock()
	defer fake.getApplicationApplicationInstanceStatusesMutex.RUnlock()
	return len(fake.getApplicationApplicationInstanceStatusesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstanceStatusesCalls(stub func(string) (map[int]ccv2.ApplicationInstanceStatus, ccv2.Warnings, error)) {
	fake.getApplicationApplicationInstanceStatusesMutex.Lock()
	defer fake.getApplicationApplicationInstanceStatusesMutex.Unlock()
	fake.GetApplicationApplicationInstanceStatusesStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstanceStatusesArgsForCall(i int) string {
	fake.getApplicationApplicationInstanceStatusesMutex.RLock()
	defer fake.getApplicationApplicationInstanceStatusesMutex.RUnlock()
	argsForCall := fake.getApplicationApplicationInstanceStatusesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstanceStatusesReturns(result1 map[int]ccv2.ApplicationInstanceStatus, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationApplicationInstanceStatusesMutex.Lock()
	defer fake.getApplicationApplicationInstanceStatusesMutex.Unlock()
	fake.GetApplicationApplicationInstanceStatusesStub = nil
	fake.getApplicationApplicationInstanceStatusesReturns = struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstanceStatusesReturnsOnCall(i int, result1 map[int]ccv2.ApplicationInstanceStatus, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationApplicationInstanceStatusesMutex.Lock()
	defer fake.getApplicationApplicationInstanceStatusesMutex.Unlock()
	fake.GetApplicationApplicationInstanceStatusesStub = nil
	if fake.getApplicationApplicationInstanceStatusesReturnsOnCall == nil {
		fake.getApplicationApplicationInstanceStatusesReturnsOnCall = make(map[int]struct {
			result1 map[int]ccv2.ApplicationInstanceStatus
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationApplicationInstanceStatusesReturnsOnCall[i] = struct {
		result1 map[int]ccv2.ApplicationInstanceStatus
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstances(arg1 string) (map[int]ccv2.ApplicationInstance, ccv2.Warnings, error) {
	fake.getApplicationApplicationInstancesMutex.Lock()
	ret, specificReturn := fake.getApplicationApplicationInstancesReturnsOnCall[len(fake.getApplicationApplicationInstancesArgsForCall)]
	fake.getApplicationApplicationInstancesArgsForCall = append(fake.getApplicationApplicationInstancesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationApplicationInstances", []interface{}{arg1})
	fake.getApplicationApplicationInstancesMutex.Unlock()
	if fake.GetApplicationApplicationInstancesStub != nil {
		return fake.GetApplicationApplicationInstancesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationApplicationInstancesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstancesCallCount() int {
	fake.getApplicationApplicationInstancesMutex.RLock()
	defer fake.getApplicationApplicationInstancesMutex.RUnlock()
	return len(fake.getApplicationApplicationInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstancesCalls(stub func(string) (map[int]ccv2.ApplicationInstance, ccv2.Warnings, error)) {
	fake.getApplicationApplicationInstancesMutex.Lock()
	defer fake.getApplicationApplicationInstancesMutex.Unlock()
	fake.GetApplicationApplicationInstancesStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstancesArgsForCall(i int) string {
	fake.getApplicationApplicationInstancesMutex.RLock()
	defer fake.getApplicationApplicationInstancesMutex.RUnlock()
	argsForCall := fake.getApplicationApplicationInstancesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstancesReturns(result1 map[int]ccv2.ApplicationInstance, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationApplicationInstancesMutex.Lock()
	defer fake.getApplicationApplicationInstancesMutex.Unlock()
	fake.GetApplicationApplicationInstancesStub = nil
	fake.getApplicationApplicationInstancesReturns = struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationApplicationInstancesReturnsOnCall(i int, result1 map[int]ccv2.ApplicationInstance, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationApplicationInstancesMutex.Lock()
	defer fake.getApplicationApplicationInstancesMutex.Unlock()
	fake.GetApplicationApplicationInstancesStub = nil
	if fake.getApplicationApplicationInstancesReturnsOnCall == nil {
		fake.getApplicationApplicationInstancesReturnsOnCall = make(map[int]struct {
			result1 map[int]ccv2.ApplicationInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationApplicationInstancesReturnsOnCall[i] = struct {
		result1 map[int]ccv2.ApplicationInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRoutes(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error) {
	fake.getApplicationRoutesMutex.Lock()
	ret, specificReturn := fake.getApplicationRoutesReturnsOnCall[len(fake.getApplicationRoutesArgsForCall)]
	fake.getApplicationRoutesArgsForCall = append(fake.getApplicationRoutesArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationRoutes", []interface{}{arg1, arg2})
	fake.getApplicationRoutesMutex.Unlock()
	if fake.GetApplicationRoutesStub != nil {
		return fake.GetApplicationRoutesStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationRoutesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesCallCount() int {
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	return len(fake.getApplicationRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesCalls(stub func(string, ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error)) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	argsForCall := fake.getApplicationRoutesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesReturns(result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = nil
	fake.getApplicationRoutesReturns = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationRoutesReturnsOnCall(i int, result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = nil
	if fake.getApplicationRoutesReturnsOnCall == nil {
		fake.getApplicationRoutesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationRoutesReturnsOnCall[i] = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplications(arg1 ...ccv2.Filter) ([]ccv2.Application, ccv2.Warnings, error) {
	fake.getApplicationsMutex.Lock()
	ret, specificReturn := fake.getApplicationsReturnsOnCall[len(fake.getApplicationsArgsForCall)]
	fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetApplications", []interface{}{arg1})
	fake.getApplicationsMutex.Unlock()
	if fake.GetApplicationsStub != nil {
		return fake.GetApplicationsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationsCallCount() int {
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	return len(fake.getApplicationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationsCalls(stub func(...ccv2.Filter) ([]ccv2.Application, ccv2.Warnings, error)) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationsArgsForCall(i int) []ccv2.Filter {
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	argsForCall := fake.getApplicationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationsReturns(result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = nil
	fake.getApplicationsReturns = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationsReturnsOnCall(i int, result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = nil
	if fake.getApplicationsReturnsOnCall == nil {
		fake.getApplicationsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getApplicationsReturnsOnCall[i] = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildpacks(arg1 ...ccv2.Filter) ([]ccv2.Buildpack, ccv2.Warnings, error) {
	fake.getBuildpacksMutex.Lock()
	ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)]
	fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetBuildpacks", []interface{}{arg1})
	fake.getBuildpacksMutex.Unlock()
	if fake.GetBuildpacksStub != nil {
		return fake.GetBuildpacksStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getBuildpacksReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetBuildpacksCallCount() int {
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	return len(fake.getBuildpacksArgsForCall)
}

func (fake *FakeCloudControllerClient) GetBuildpacksCalls(stub func(...ccv2.Filter) ([]ccv2.Buildpack, ccv2.Warnings, error)) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = stub
}

func (fake *FakeCloudControllerClient) GetBuildpacksArgsForCall(i int) []ccv2.Filter {
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	argsForCall := fake.getBuildpacksArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetBuildpacksReturns(result1 []ccv2.Buildpack, result2 ccv2.Warnings, result3 error) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = nil
	fake.getBuildpacksReturns = struct {
		result1 []ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildpacksReturnsOnCall(i int, result1 []ccv2.Buildpack, result2 ccv2.Warnings, result3 error) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = nil
	if fake.getBuildpacksReturnsOnCall == nil {
		fake.getBuildpacksReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Buildpack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getBuildpacksReturnsOnCall[i] = struct {
		result1 []ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetConfigFeatureFlags() ([]ccv2.FeatureFlag, ccv2.Warnings, error) {
	fake.getConfigFeatureFlagsMutex.Lock()
	ret, specificReturn := fake.getConfigFeatureFlagsReturnsOnCall[len(fake.getConfigFeatureFlagsArgsForCall)]
	fake.getConfigFeatureFlagsArgsForCall = append(fake.getConfigFeatureFlagsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetConfigFeatureFlags", []interface{}{})
	fake.getConfigFeatureFlagsMutex.Unlock()
	if fake.GetConfigFeatureFlagsStub != nil {
		return fake.GetConfigFeatureFlagsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getConfigFeatureFlagsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetConfigFeatureFlagsCallCount() int {
	fake.getConfigFeatureFlagsMutex.RLock()
	defer fake.getConfigFeatureFlagsMutex.RUnlock()
	return len(fake.getConfigFeatureFlagsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetConfigFeatureFlagsCalls(stub func() ([]ccv2.FeatureFlag, ccv2.Warnings, error)) {
	fake.getConfigFeatureFlagsMutex.Lock()
	defer fake.getConfigFeatureFlagsMutex.Unlock()
	fake.GetConfigFeatureFlagsStub = stub
}

func (fake *FakeCloudControllerClient) GetConfigFeatureFlagsReturns(result1 []ccv2.FeatureFlag, result2 ccv2.Warnings, result3 error) {
	fake.getConfigFeatureFlagsMutex.Lock()
	defer fake.getConfigFeatureFlagsMutex.Unlock()
	fake.GetConfigFeatureFlagsStub = nil
	fake.getConfigFeatureFlagsReturns = struct {
		result1 []ccv2.FeatureFlag
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetConfigFeatureFlagsReturnsOnCall(i int, result1 []ccv2.FeatureFlag, result2 ccv2.Warnings, result3 error) {
	fake.getConfigFeatureFlagsMutex.Lock()
	defer fake.getConfigFeatureFlagsMutex.Unlock()
	fake.GetConfigFeatureFlagsStub = nil
	if fake.getConfigFeatureFlagsReturnsOnCall == nil {
		fake.getConfigFeatureFlagsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.FeatureFlag
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getConfigFeatureFlagsReturnsOnCall[i] = struct {
		result1 []ccv2.FeatureFlag
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetJob(arg1 string) (ccv2.Job, ccv2.Warnings, error) {
	fake.getJobMutex.Lock()
	ret, specificReturn := fake.getJobReturnsOnCall[len(fake.getJobArgsForCall)]
	fake.getJobArgsForCall = append(fake.getJobArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetJob", []interface{}{arg1})
	fake.getJobMutex.Unlock()
	if fake.GetJobStub != nil {
		return fake.GetJobStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getJobReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetJobCallCount() int {
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	return len(fake.getJobArgsForCall)
}

func (fake *FakeCloudControllerClient) GetJobCalls(stub func(string) (ccv2.Job, ccv2.Warnings, error)) {
	fake.getJobMutex.Lock()
	defer fake.getJobMutex.Unlock()
	fake.GetJobStub = stub
}

func (fake *FakeCloudControllerClient) GetJobArgsForCall(i int) string {
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	argsForCall := fake.getJobArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetJobReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.getJobMutex.Lock()
	defer fake.getJobMutex.Unlock()
	fake.GetJobStub = nil
	fake.getJobReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetJobReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.getJobMutex.Lock()
	defer fake.getJobMutex.Unlock()
	fake.GetJobStub = nil
	if fake.getJobReturnsOnCall == nil {
		fake.getJobReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getJobReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganization(arg1 string) (ccv2.Organization, ccv2.Warnings, error) {
	fake.getOrganizationMutex.Lock()
	ret, specificReturn := fake.getOrganizationReturnsOnCall[len(fake.getOrganizationArgsForCall)]
	fake.getOrganizationArgsForCall = append(fake.getOrganizationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganization", []interface{}{arg1})
	fake.getOrganizationMutex.Unlock()
	if fake.GetOrganizationStub != nil {
		return fake.GetOrganizationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationCallCount() int {
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	return len(fake.getOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationCalls(stub func(string) (ccv2.Organization, ccv2.Warnings, error)) {
	fake.getOrganizationMutex.Lock()
	defer fake.getOrganizationMutex.Unlock()
	fake.GetOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationArgsForCall(i int) string {
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	argsForCall := fake.getOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationReturns(result1 ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationMutex.Lock()
	defer fake.getOrganizationMutex.Unlock()
	fake.GetOrganizationStub = nil
	fake.getOrganizationReturns = struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationReturnsOnCall(i int, result1 ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationMutex.Lock()
	defer fake.getOrganizationMutex.Unlock()
	fake.GetOrganizationStub = nil
	if fake.getOrganizationReturnsOnCall == nil {
		fake.getOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Organization
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationReturnsOnCall[i] = struct {
		result1 ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomains(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.Domain, ccv2.Warnings, error) {
	fake.getOrganizationPrivateDomainsMutex.Lock()
	ret, specificReturn := fake.getOrganizationPrivateDomainsReturnsOnCall[len(fake.getOrganizationPrivateDomainsArgsForCall)]
	fake.getOrganizationPrivateDomainsArgsForCall = append(fake.getOrganizationPrivateDomainsArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetOrganizationPrivateDomains", []interface{}{arg1, arg2})
	fake.getOrganizationPrivateDomainsMutex.Unlock()
	if fake.GetOrganizationPrivateDomainsStub != nil {
		return fake.GetOrganizationPrivateDomainsStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationPrivateDomainsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsCallCount() int {
	fake.getOrganizationPrivateDomainsMutex.RLock()
	defer fake.getOrganizationPrivateDomainsMutex.RUnlock()
	return len(fake.getOrganizationPrivateDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsCalls(stub func(string, ...ccv2.Filter) ([]ccv2.Domain, ccv2.Warnings, error)) {
	fake.getOrganizationPrivateDomainsMutex.Lock()
	defer fake.getOrganizationPrivateDomainsMutex.Unlock()
	fake.GetOrganizationPrivateDomainsStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getOrganizationPrivateDomainsMutex.RLock()
	defer fake.getOrganizationPrivateDomainsMutex.RUnlock()
	argsForCall := fake.getOrganizationPrivateDomainsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsReturns(result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationPrivateDomainsMutex.Lock()
	defer fake.getOrganizationPrivateDomainsMutex.Unlock()
	fake.GetOrganizationPrivateDomainsStub = nil
	fake.getOrganizationPrivateDomainsReturns = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationPrivateDomainsReturnsOnCall(i int, result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationPrivateDomainsMutex.Lock()
	defer fake.getOrganizationPrivateDomainsMutex.Unlock()
	fake.GetOrganizationPrivateDomainsStub = nil
	if fake.getOrganizationPrivateDomainsReturnsOnCall == nil {
		fake.getOrganizationPrivateDomainsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationPrivateDomainsReturnsOnCall[i] = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuota(arg1 string) (ccv2.OrganizationQuota, ccv2.Warnings, error) {
	fake.getOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.getOrganizationQuotaReturnsOnCall[len(fake.getOrganizationQuotaArgsForCall)]
	fake.getOrganizationQuotaArgsForCall = append(fake.getOrganizationQuotaArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationQuota", []interface{}{arg1})
	fake.getOrganizationQuotaMutex.Unlock()
	if fake.GetOrganizationQuotaStub != nil {
		return fake.GetOrganizationQuotaStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationQuotaReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaCallCount() int {
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	return len(fake.getOrganizationQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaCalls(stub func(string) (ccv2.OrganizationQuota, ccv2.Warnings, error)) {
	fake.getOrganizationQuotaMutex.Lock()
	defer fake.getOrganizationQuotaMutex.Unlock()
	fake.GetOrganizationQuotaStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaArgsForCall(i int) string {
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.getOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturns(result1 ccv2.OrganizationQuota, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationQuotaMutex.Lock()
	defer fake.getOrganizationQuotaMutex.Unlock()
	fake.GetOrganizationQuotaStub = nil
	fake.getOrganizationQuotaReturns = struct {
		result1 ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotaReturnsOnCall(i int, result1 ccv2.OrganizationQuota, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationQuotaMutex.Lock()
	defer fake.getOrganizationQuotaMutex.Unlock()
	fake.GetOrganizationQuotaStub = nil
	if fake.getOrganizationQuotaReturnsOnCall == nil {
		fake.getOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv2.OrganizationQuota
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationQuotaReturnsOnCall[i] = struct {
		result1 ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotas(arg1 ...ccv2.Filter) ([]ccv2.OrganizationQuota, ccv2.Warnings, error) {
	fake.getOrganizationQuotasMutex.Lock()
	ret, specificReturn := fake.getOrganizationQuotasReturnsOnCall[len(fake.getOrganizationQuotasArgsForCall)]
	fake.getOrganizationQuotasArgsForCall = append(fake.getOrganizationQuotasArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetOrganizationQuotas", []interface{}{arg1})
	fake.getOrganizationQuotasMutex.Unlock()
	if fake.GetOrganizationQuotasStub != nil {
		return fake.GetOrganizationQuotasStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationQuotasReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasCallCount() int {
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	return len(fake.getOrganizationQuotasArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasCalls(stub func(...ccv2.Filter) ([]ccv2.OrganizationQuota, ccv2.Warnings, error)) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasArgsForCall(i int) []ccv2.Filter {
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	argsForCall := fake.getOrganizationQuotasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasReturns(result1 []ccv2.OrganizationQuota, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = nil
	fake.getOrganizationQuotasReturns = struct {
		result1 []ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationQuotasReturnsOnCall(i int, result1 []ccv2.OrganizationQuota, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = nil
	if fake.getOrganizationQuotasReturnsOnCall == nil {
		fake.getOrganizationQuotasReturnsOnCall = make(map[int]struct {
			result1 []ccv2.OrganizationQuota
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationQuotasReturnsOnCall[i] = struct {
		result1 []ccv2.OrganizationQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizations(arg1 ...ccv2.Filter) ([]ccv2.Organization, ccv2.Warnings, error) {
	fake.getOrganizationsMutex.Lock()
	ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)]
	fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetOrganizations", []interface{}{arg1})
	fake.getOrganizationsMutex.Unlock()
	if fake.GetOrganizationsStub != nil {
		return fake.GetOrganizationsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationsCallCount() int {
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	return len(fake.getOrganizationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationsCalls(stub func(...ccv2.Filter) ([]ccv2.Organization, ccv2.Warnings, error)) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationsArgsForCall(i int) []ccv2.Filter {
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	argsForCall := fake.getOrganizationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationsReturns(result1 []ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = nil
	fake.getOrganizationsReturns = struct {
		result1 []ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationsReturnsOnCall(i int, result1 []ccv2.Organization, result2 ccv2.Warnings, result3 error) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = nil
	if fake.getOrganizationsReturnsOnCall == nil {
		fake.getOrganizationsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Organization
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getOrganizationsReturnsOnCall[i] = struct {
		result1 []ccv2.Organization
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPrivateDomain(arg1 string) (ccv2.Domain, ccv2.Warnings, error) {
	fake.getPrivateDomainMutex.Lock()
	ret, specificReturn := fake.getPrivateDomainReturnsOnCall[len(fake.getPrivateDomainArgsForCall)]
	fake.getPrivateDomainArgsForCall = append(fake.getPrivateDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetPrivateDomain", []interface{}{arg1})
	fake.getPrivateDomainMutex.Unlock()
	if fake.GetPrivateDomainStub != nil {
		return fake.GetPrivateDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getPrivateDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetPrivateDomainCallCount() int {
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	return len(fake.getPrivateDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPrivateDomainCalls(stub func(string) (ccv2.Domain, ccv2.Warnings, error)) {
	fake.getPrivateDomainMutex.Lock()
	defer fake.getPrivateDomainMutex.Unlock()
	fake.GetPrivateDomainStub = stub
}

func (fake *FakeCloudControllerClient) GetPrivateDomainArgsForCall(i int) string {
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	argsForCall := fake.getPrivateDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetPrivateDomainReturns(result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getPrivateDomainMutex.Lock()
	defer fake.getPrivateDomainMutex.Unlock()
	fake.GetPrivateDomainStub = nil
	fake.getPrivateDomainReturns = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPrivateDomainReturnsOnCall(i int, result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getPrivateDomainMutex.Lock()
	defer fake.getPrivateDomainMutex.Unlock()
	fake.GetPrivateDomainStub = nil
	if fake.getPrivateDomainReturnsOnCall == nil {
		fake.getPrivateDomainReturnsOnCall = make(map[int]struct {
			result1 ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getPrivateDomainReturnsOnCall[i] = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRouteApplications(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.Application, ccv2.Warnings, error) {
	fake.getRouteApplicationsMutex.Lock()
	ret, specificReturn := fake.getRouteApplicationsReturnsOnCall[len(fake.getRouteApplicationsArgsForCall)]
	fake.getRouteApplicationsArgsForCall = append(fake.getRouteApplicationsArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetRouteApplications", []interface{}{arg1, arg2})
	fake.getRouteApplicationsMutex.Unlock()
	if fake.GetRouteApplicationsStub != nil {
		return fake.GetRouteApplicationsStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRouteApplicationsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsCallCount() int {
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	return len(fake.getRouteApplicationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsCalls(stub func(string, ...ccv2.Filter) ([]ccv2.Application, ccv2.Warnings, error)) {
	fake.getRouteApplicationsMutex.Lock()
	defer fake.getRouteApplicationsMutex.Unlock()
	fake.GetRouteApplicationsStub = stub
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	argsForCall := fake.getRouteApplicationsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsReturns(result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.getRouteApplicationsMutex.Lock()
	defer fake.getRouteApplicationsMutex.Unlock()
	fake.GetRouteApplicationsStub = nil
	fake.getRouteApplicationsReturns = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRouteApplicationsReturnsOnCall(i int, result1 []ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.getRouteApplicationsMutex.Lock()
	defer fake.getRouteApplicationsMutex.Unlock()
	fake.GetRouteApplicationsStub = nil
	if fake.getRouteApplicationsReturnsOnCall == nil {
		fake.getRouteApplicationsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getRouteApplicationsReturnsOnCall[i] = struct {
		result1 []ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRoutes(arg1 ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error) {
	fake.getRoutesMutex.Lock()
	ret, specificReturn := fake.getRoutesReturnsOnCall[len(fake.getRoutesArgsForCall)]
	fake.getRoutesArgsForCall = append(fake.getRoutesArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetRoutes", []interface{}{arg1})
	fake.getRoutesMutex.Unlock()
	if fake.GetRoutesStub != nil {
		return fake.GetRoutesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRoutesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetRoutesCallCount() int {
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	return len(fake.getRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetRoutesCalls(stub func(...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error)) {
	fake.getRoutesMutex.Lock()
	defer fake.getRoutesMutex.Unlock()
	fake.GetRoutesStub = stub
}

func (fake *FakeCloudControllerClient) GetRoutesArgsForCall(i int) []ccv2.Filter {
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	argsForCall := fake.getRoutesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetRoutesReturns(result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.getRoutesMutex.Lock()
	defer fake.getRoutesMutex.Unlock()
	fake.GetRoutesStub = nil
	fake.getRoutesReturns = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetRoutesReturnsOnCall(i int, result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.getRoutesMutex.Lock()
	defer fake.getRoutesMutex.Unlock()
	fake.GetRoutesStub = nil
	if fake.getRoutesReturnsOnCall == nil {
		fake.getRoutesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getRoutesReturnsOnCall[i] = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupSpaces(arg1 string) ([]ccv2.Space, ccv2.Warnings, error) {
	fake.getSecurityGroupSpacesMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupSpacesReturnsOnCall[len(fake.getSecurityGroupSpacesArgsForCall)]
	fake.getSecurityGroupSpacesArgsForCall = append(fake.getSecurityGroupSpacesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSecurityGroupSpaces", []interface{}{arg1})
	fake.getSecurityGroupSpacesMutex.Unlock()
	if fake.GetSecurityGroupSpacesStub != nil {
		return fake.GetSecurityGroupSpacesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSecurityGroupSpacesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSecurityGroupSpacesCallCount() int {
	fake.getSecurityGroupSpacesMutex.RLock()
	defer fake.getSecurityGroupSpacesMutex.RUnlock()
	return len(fake.getSecurityGroupSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSecurityGroupSpacesCalls(stub func(string) ([]ccv2.Space, ccv2.Warnings, error)) {
	fake.getSecurityGroupSpacesMutex.Lock()
	defer fake.getSecurityGroupSpacesMutex.Unlock()
	fake.GetSecurityGroupSpacesStub = stub
}

func (fake *FakeCloudControllerClient) GetSecurityGroupSpacesArgsForCall(i int) string {
	fake.getSecurityGroupSpacesMutex.RLock()
	defer fake.getSecurityGroupSpacesMutex.RUnlock()
	argsForCall := fake.getSecurityGroupSpacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSecurityGroupSpacesReturns(result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.getSecurityGroupSpacesMutex.Lock()
	defer fake.getSecurityGroupSpacesMutex.Unlock()
	fake.GetSecurityGroupSpacesStub = nil
	fake.getSecurityGroupSpacesReturns = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupSpacesReturnsOnCall(i int, result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.getSecurityGroupSpacesMutex.Lock()
	defer fake.getSecurityGroupSpacesMutex.Unlock()
	fake.GetSecurityGroupSpacesStub = nil
	if fake.getSecurityGroupSpacesReturnsOnCall == nil {
		fake.getSecurityGroupSpacesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupSpacesReturnsOnCall[i] = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupStagingSpaces(arg1 string) ([]ccv2.Space, ccv2.Warnings, error) {
	fake.getSecurityGroupStagingSpacesMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupStagingSpacesReturnsOnCall[len(fake.getSecurityGroupStagingSpacesArgsForCall)]
	fake.getSecurityGroupStagingSpacesArgsForCall = append(fake.getSecurityGroupStagingSpacesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSecurityGroupStagingSpaces", []interface{}{arg1})
	fake.getSecurityGroupStagingSpacesMutex.Unlock()
	if fake.GetSecurityGroupStagingSpacesStub != nil {
		return fake.GetSecurityGroupStagingSpacesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSecurityGroupStagingSpacesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSecurityGroupStagingSpacesCallCount() int {
	fake.getSecurityGroupStagingSpacesMutex.RLock()
	defer fake.getSecurityGroupStagingSpacesMutex.RUnlock()
	return len(fake.getSecurityGroupStagingSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSecurityGroupStagingSpacesCalls(stub func(string) ([]ccv2.Space, ccv2.Warnings, error)) {
	fake.getSecurityGroupStagingSpacesMutex.Lock()
	defer fake.getSecurityGroupStagingSpacesMutex.Unlock()
	fake.GetSecurityGroupStagingSpacesStub = stub
}

func (fake *FakeCloudControllerClient) GetSecurityGroupStagingSpacesArgsForCall(i int) string {
	fake.getSecurityGroupStagingSpacesMutex.RLock()
	defer fake.getSecurityGroupStagingSpacesMutex.RUnlock()
	argsForCall := fake.getSecurityGroupStagingSpacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSecurityGroupStagingSpacesReturns(result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.getSecurityGroupStagingSpacesMutex.Lock()
	defer fake.getSecurityGroupStagingSpacesMutex.Unlock()
	fake.GetSecurityGroupStagingSpacesStub = nil
	fake.getSecurityGroupStagingSpacesReturns = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupStagingSpacesReturnsOnCall(i int, result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.getSecurityGroupStagingSpacesMutex.Lock()
	defer fake.getSecurityGroupStagingSpacesMutex.Unlock()
	fake.GetSecurityGroupStagingSpacesStub = nil
	if fake.getSecurityGroupStagingSpacesReturnsOnCall == nil {
		fake.getSecurityGroupStagingSpacesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupStagingSpacesReturnsOnCall[i] = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroups(arg1 ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error) {
	fake.getSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupsReturnsOnCall[len(fake.getSecurityGroupsArgsForCall)]
	fake.getSecurityGroupsArgsForCall = append(fake.getSecurityGroupsArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetSecurityGroups", []interface{}{arg1})
	fake.getSecurityGroupsMutex.Unlock()
	if fake.GetSecurityGroupsStub != nil {
		return fake.GetSecurityGroupsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSecurityGroupsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsCallCount() int {
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	return len(fake.getSecurityGroupsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsCalls(stub func(...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error)) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = stub
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsArgsForCall(i int) []ccv2.Filter {
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	argsForCall := fake.getSecurityGroupsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsReturns(result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = nil
	fake.getSecurityGroupsReturns = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSecurityGroupsReturnsOnCall(i int, result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = nil
	if fake.getSecurityGroupsReturnsOnCall == nil {
		fake.getSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SecurityGroup
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupsReturnsOnCall[i] = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetService(arg1 string) (ccv2.Service, ccv2.Warnings, error) {
	fake.getServiceMutex.Lock()
	ret, specificReturn := fake.getServiceReturnsOnCall[len(fake.getServiceArgsForCall)]
	fake.getServiceArgsForCall = append(fake.getServiceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetService", []interface{}{arg1})
	fake.getServiceMutex.Unlock()
	if fake.GetServiceStub != nil {
		return fake.GetServiceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceCallCount() int {
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	return len(fake.getServiceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceCalls(stub func(string) (ccv2.Service, ccv2.Warnings, error)) {
	fake.getServiceMutex.Lock()
	defer fake.getServiceMutex.Unlock()
	fake.GetServiceStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceArgsForCall(i int) string {
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	argsForCall := fake.getServiceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceReturns(result1 ccv2.Service, result2 ccv2.Warnings, result3 error) {
	fake.getServiceMutex.Lock()
	defer fake.getServiceMutex.Unlock()
	fake.GetServiceStub = nil
	fake.getServiceReturns = struct {
		result1 ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceReturnsOnCall(i int, result1 ccv2.Service, result2 ccv2.Warnings, result3 error) {
	fake.getServiceMutex.Lock()
	defer fake.getServiceMutex.Unlock()
	fake.GetServiceStub = nil
	if fake.getServiceReturnsOnCall == nil {
		fake.getServiceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Service
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceReturnsOnCall[i] = struct {
		result1 ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBindings(arg1 ...ccv2.Filter) ([]ccv2.ServiceBinding, ccv2.Warnings, error) {
	fake.getServiceBindingsMutex.Lock()
	ret, specificReturn := fake.getServiceBindingsReturnsOnCall[len(fake.getServiceBindingsArgsForCall)]
	fake.getServiceBindingsArgsForCall = append(fake.getServiceBindingsArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetServiceBindings", []interface{}{arg1})
	fake.getServiceBindingsMutex.Unlock()
	if fake.GetServiceBindingsStub != nil {
		return fake.GetServiceBindingsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceBindingsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceBindingsCallCount() int {
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	return len(fake.getServiceBindingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceBindingsCalls(stub func(...ccv2.Filter) ([]ccv2.ServiceBinding, ccv2.Warnings, error)) {
	fake.getServiceBindingsMutex.Lock()
	defer fake.getServiceBindingsMutex.Unlock()
	fake.GetServiceBindingsStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceBindingsArgsForCall(i int) []ccv2.Filter {
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	argsForCall := fake.getServiceBindingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceBindingsReturns(result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.getServiceBindingsMutex.Lock()
	defer fake.getServiceBindingsMutex.Unlock()
	fake.GetServiceBindingsStub = nil
	fake.getServiceBindingsReturns = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBindingsReturnsOnCall(i int, result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.getServiceBindingsMutex.Lock()
	defer fake.getServiceBindingsMutex.Unlock()
	fake.GetServiceBindingsStub = nil
	if fake.getServiceBindingsReturnsOnCall == nil {
		fake.getServiceBindingsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceBindingsReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBrokers(arg1 ...ccv2.Filter) ([]ccv2.ServiceBroker, ccv2.Warnings, error) {
	fake.getServiceBrokersMutex.Lock()
	ret, specificReturn := fake.getServiceBrokersReturnsOnCall[len(fake.getServiceBrokersArgsForCall)]
	fake.getServiceBrokersArgsForCall = append(fake.getServiceBrokersArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetServiceBrokers", []interface{}{arg1})
	fake.getServiceBrokersMutex.Unlock()
	if fake.GetServiceBrokersStub != nil {
		return fake.GetServiceBrokersStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceBrokersReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceBrokersCallCount() int {
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	return len(fake.getServiceBrokersArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceBrokersCalls(stub func(...ccv2.Filter) ([]ccv2.ServiceBroker, ccv2.Warnings, error)) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceBrokersArgsForCall(i int) []ccv2.Filter {
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	argsForCall := fake.getServiceBrokersArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceBrokersReturns(result1 []ccv2.ServiceBroker, result2 ccv2.Warnings, result3 error) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = nil
	fake.getServiceBrokersReturns = struct {
		result1 []ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceBrokersReturnsOnCall(i int, result1 []ccv2.ServiceBroker, result2 ccv2.Warnings, result3 error) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = nil
	if fake.getServiceBrokersReturnsOnCall == nil {
		fake.getServiceBrokersReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceBroker
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceBrokersReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceBroker
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstance(arg1 string) (ccv2.ServiceInstance, ccv2.Warnings, error) {
	fake.getServiceInstanceMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceReturnsOnCall[len(fake.getServiceInstanceArgsForCall)]
	fake.getServiceInstanceArgsForCall = append(fake.getServiceInstanceArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceInstance", []interface{}{arg1})
	fake.getServiceInstanceMutex.Unlock()
	if fake.GetServiceInstanceStub != nil {
		return fake.GetServiceInstanceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceCallCount() int {
	fake.getServiceInstanceMutex.RLock()
	defer fake.getServiceInstanceMutex.RUnlock()
	return len(fake.getServiceInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceCalls(stub func(string) (ccv2.ServiceInstance, ccv2.Warnings, error)) {
	fake.getServiceInstanceMutex.Lock()
	defer fake.getServiceInstanceMutex.Unlock()
	fake.GetServiceInstanceStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceArgsForCall(i int) string {
	fake.getServiceInstanceMutex.RLock()
	defer fake.getServiceInstanceMutex.RUnlock()
	argsForCall := fake.getServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceReturns(result1 ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceMutex.Lock()
	defer fake.getServiceInstanceMutex.Unlock()
	fake.GetServiceInstanceStub = nil
	fake.getServiceInstanceReturns = struct {
		result1 ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceReturnsOnCall(i int, result1 ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceMutex.Lock()
	defer fake.getServiceInstanceMutex.Unlock()
	fake.GetServiceInstanceStub = nil
	if fake.getServiceInstanceReturnsOnCall == nil {
		fake.getServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceReturnsOnCall[i] = struct {
		result1 ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceServiceBindings(arg1 string) ([]ccv2.ServiceBinding, ccv2.Warnings, error) {
	fake.getServiceInstanceServiceBindingsMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceServiceBindingsReturnsOnCall[len(fake.getServiceInstanceServiceBindingsArgsForCall)]
	fake.getServiceInstanceServiceBindingsArgsForCall = append(fake.getServiceInstanceServiceBindingsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceInstanceServiceBindings", []interface{}{arg1})
	fake.getServiceInstanceServiceBindingsMutex.Unlock()
	if fake.GetServiceInstanceServiceBindingsStub != nil {
		return fake.GetServiceInstanceServiceBindingsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceServiceBindingsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceServiceBindingsCallCount() int {
	fake.getServiceInstanceServiceBindingsMutex.RLock()
	defer fake.getServiceInstanceServiceBindingsMutex.RUnlock()
	return len(fake.getServiceInstanceServiceBindingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceServiceBindingsCalls(stub func(string) ([]ccv2.ServiceBinding, ccv2.Warnings, error)) {
	fake.getServiceInstanceServiceBindingsMutex.Lock()
	defer fake.getServiceInstanceServiceBindingsMutex.Unlock()
	fake.GetServiceInstanceServiceBindingsStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceServiceBindingsArgsForCall(i int) string {
	fake.getServiceInstanceServiceBindingsMutex.RLock()
	defer fake.getServiceInstanceServiceBindingsMutex.RUnlock()
	argsForCall := fake.getServiceInstanceServiceBindingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceServiceBindingsReturns(result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceServiceBindingsMutex.Lock()
	defer fake.getServiceInstanceServiceBindingsMutex.Unlock()
	fake.GetServiceInstanceServiceBindingsStub = nil
	fake.getServiceInstanceServiceBindingsReturns = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceServiceBindingsReturnsOnCall(i int, result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceServiceBindingsMutex.Lock()
	defer fake.getServiceInstanceServiceBindingsMutex.Unlock()
	fake.GetServiceInstanceServiceBindingsStub = nil
	if fake.getServiceInstanceServiceBindingsReturnsOnCall == nil {
		fake.getServiceInstanceServiceBindingsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceServiceBindingsReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedFrom(arg1 string) (ccv2.ServiceInstanceSharedFrom, ccv2.Warnings, error) {
	fake.getServiceInstanceSharedFromMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceSharedFromReturnsOnCall[len(fake.getServiceInstanceSharedFromArgsForCall)]
	fake.getServiceInstanceSharedFromArgsForCall = append(fake.getServiceInstanceSharedFromArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceInstanceSharedFrom", []interface{}{arg1})
	fake.getServiceInstanceSharedFromMutex.Unlock()
	if fake.GetServiceInstanceSharedFromStub != nil {
		return fake.GetServiceInstanceSharedFromStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceSharedFromReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedFromCallCount() int {
	fake.getServiceInstanceSharedFromMutex.RLock()
	defer fake.getServiceInstanceSharedFromMutex.RUnlock()
	return len(fake.getServiceInstanceSharedFromArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedFromCalls(stub func(string) (ccv2.ServiceInstanceSharedFrom, ccv2.Warnings, error)) {
	fake.getServiceInstanceSharedFromMutex.Lock()
	defer fake.getServiceInstanceSharedFromMutex.Unlock()
	fake.GetServiceInstanceSharedFromStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedFromArgsForCall(i int) string {
	fake.getServiceInstanceSharedFromMutex.RLock()
	defer fake.getServiceInstanceSharedFromMutex.RUnlock()
	argsForCall := fake.getServiceInstanceSharedFromArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedFromReturns(result1 ccv2.ServiceInstanceSharedFrom, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceSharedFromMutex.Lock()
	defer fake.getServiceInstanceSharedFromMutex.Unlock()
	fake.GetServiceInstanceSharedFromStub = nil
	fake.getServiceInstanceSharedFromReturns = struct {
		result1 ccv2.ServiceInstanceSharedFrom
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedFromReturnsOnCall(i int, result1 ccv2.ServiceInstanceSharedFrom, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceSharedFromMutex.Lock()
	defer fake.getServiceInstanceSharedFromMutex.Unlock()
	fake.GetServiceInstanceSharedFromStub = nil
	if fake.getServiceInstanceSharedFromReturnsOnCall == nil {
		fake.getServiceInstanceSharedFromReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServiceInstanceSharedFrom
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceSharedFromReturnsOnCall[i] = struct {
		result1 ccv2.ServiceInstanceSharedFrom
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedTos(arg1 string) ([]ccv2.ServiceInstanceSharedTo, ccv2.Warnings, error) {
	fake.getServiceInstanceSharedTosMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceSharedTosReturnsOnCall[len(fake.getServiceInstanceSharedTosArgsForCall)]
	fake.getServiceInstanceSharedTosArgsForCall = append(fake.getServiceInstanceSharedTosArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceInstanceSharedTos", []interface{}{arg1})
	fake.getServiceInstanceSharedTosMutex.Unlock()
	if fake.GetServiceInstanceSharedTosStub != nil {
		return fake.GetServiceInstanceSharedTosStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceSharedTosReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedTosCallCount() int {
	fake.getServiceInstanceSharedTosMutex.RLock()
	defer fake.getServiceInstanceSharedTosMutex.RUnlock()
	return len(fake.getServiceInstanceSharedTosArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedTosCalls(stub func(string) ([]ccv2.ServiceInstanceSharedTo, ccv2.Warnings, error)) {
	fake.getServiceInstanceSharedTosMutex.Lock()
	defer fake.getServiceInstanceSharedTosMutex.Unlock()
	fake.GetServiceInstanceSharedTosStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedTosArgsForCall(i int) string {
	fake.getServiceInstanceSharedTosMutex.RLock()
	defer fake.getServiceInstanceSharedTosMutex.RUnlock()
	argsForCall := fake.getServiceInstanceSharedTosArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedTosReturns(result1 []ccv2.ServiceInstanceSharedTo, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceSharedTosMutex.Lock()
	defer fake.getServiceInstanceSharedTosMutex.Unlock()
	fake.GetServiceInstanceSharedTosStub = nil
	fake.getServiceInstanceSharedTosReturns = struct {
		result1 []ccv2.ServiceInstanceSharedTo
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstanceSharedTosReturnsOnCall(i int, result1 []ccv2.ServiceInstanceSharedTo, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstanceSharedTosMutex.Lock()
	defer fake.getServiceInstanceSharedTosMutex.Unlock()
	fake.GetServiceInstanceSharedTosStub = nil
	if fake.getServiceInstanceSharedTosReturnsOnCall == nil {
		fake.getServiceInstanceSharedTosReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceInstanceSharedTo
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceSharedTosReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceInstanceSharedTo
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstances(arg1 ...ccv2.Filter) ([]ccv2.ServiceInstance, ccv2.Warnings, error) {
	fake.getServiceInstancesMutex.Lock()
	ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)]
	fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetServiceInstances", []interface{}{arg1})
	fake.getServiceInstancesMutex.Unlock()
	if fake.GetServiceInstancesStub != nil {
		return fake.GetServiceInstancesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstancesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServiceInstancesCallCount() int {
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	return len(fake.getServiceInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServiceInstancesCalls(stub func(...ccv2.Filter) ([]ccv2.ServiceInstance, ccv2.Warnings, error)) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = stub
}

func (fake *FakeCloudControllerClient) GetServiceInstancesArgsForCall(i int) []ccv2.Filter {
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	argsForCall := fake.getServiceInstancesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServiceInstancesReturns(result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = nil
	fake.getServiceInstancesReturns = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstancesReturnsOnCall(i int, result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = nil
	if fake.getServiceInstancesReturnsOnCall == nil {
		fake.getServiceInstancesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServiceInstancesReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlan(arg1 string) (ccv2.ServicePlan, ccv2.Warnings, error) {
	fake.getServicePlanMutex.Lock()
	ret, specificReturn := fake.getServicePlanReturnsOnCall[len(fake.getServicePlanArgsForCall)]
	fake.getServicePlanArgsForCall = append(fake.getServicePlanArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServicePlan", []interface{}{arg1})
	fake.getServicePlanMutex.Unlock()
	if fake.GetServicePlanStub != nil {
		return fake.GetServicePlanStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServicePlanReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlanCallCount() int {
	fake.getServicePlanMutex.RLock()
	defer fake.getServicePlanMutex.RUnlock()
	return len(fake.getServicePlanArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlanCalls(stub func(string) (ccv2.ServicePlan, ccv2.Warnings, error)) {
	fake.getServicePlanMutex.Lock()
	defer fake.getServicePlanMutex.Unlock()
	fake.GetServicePlanStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlanArgsForCall(i int) string {
	fake.getServicePlanMutex.RLock()
	defer fake.getServicePlanMutex.RUnlock()
	argsForCall := fake.getServicePlanArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlanReturns(result1 ccv2.ServicePlan, result2 ccv2.Warnings, result3 error) {
	fake.getServicePlanMutex.Lock()
	defer fake.getServicePlanMutex.Unlock()
	fake.GetServicePlanStub = nil
	fake.getServicePlanReturns = struct {
		result1 ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanReturnsOnCall(i int, result1 ccv2.ServicePlan, result2 ccv2.Warnings, result3 error) {
	fake.getServicePlanMutex.Lock()
	defer fake.getServicePlanMutex.Unlock()
	fake.GetServicePlanStub = nil
	if fake.getServicePlanReturnsOnCall == nil {
		fake.getServicePlanReturnsOnCall = make(map[int]struct {
			result1 ccv2.ServicePlan
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServicePlanReturnsOnCall[i] = struct {
		result1 ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilities(arg1 ...ccv2.Filter) ([]ccv2.ServicePlanVisibility, ccv2.Warnings, error) {
	fake.getServicePlanVisibilitiesMutex.Lock()
	ret, specificReturn := fake.getServicePlanVisibilitiesReturnsOnCall[len(fake.getServicePlanVisibilitiesArgsForCall)]
	fake.getServicePlanVisibilitiesArgsForCall = append(fake.getServicePlanVisibilitiesArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetServicePlanVisibilities", []interface{}{arg1})
	fake.getServicePlanVisibilitiesMutex.Unlock()
	if fake.GetServicePlanVisibilitiesStub != nil {
		return fake.GetServicePlanVisibilitiesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServicePlanVisibilitiesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilitiesCallCount() int {
	fake.getServicePlanVisibilitiesMutex.RLock()
	defer fake.getServicePlanVisibilitiesMutex.RUnlock()
	return len(fake.getServicePlanVisibilitiesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilitiesCalls(stub func(...ccv2.Filter) ([]ccv2.ServicePlanVisibility, ccv2.Warnings, error)) {
	fake.getServicePlanVisibilitiesMutex.Lock()
	defer fake.getServicePlanVisibilitiesMutex.Unlock()
	fake.GetServicePlanVisibilitiesStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilitiesArgsForCall(i int) []ccv2.Filter {
	fake.getServicePlanVisibilitiesMutex.RLock()
	defer fake.getServicePlanVisibilitiesMutex.RUnlock()
	argsForCall := fake.getServicePlanVisibilitiesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilitiesReturns(result1 []ccv2.ServicePlanVisibility, result2 ccv2.Warnings, result3 error) {
	fake.getServicePlanVisibilitiesMutex.Lock()
	defer fake.getServicePlanVisibilitiesMutex.Unlock()
	fake.GetServicePlanVisibilitiesStub = nil
	fake.getServicePlanVisibilitiesReturns = struct {
		result1 []ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlanVisibilitiesReturnsOnCall(i int, result1 []ccv2.ServicePlanVisibility, result2 ccv2.Warnings, result3 error) {
	fake.getServicePlanVisibilitiesMutex.Lock()
	defer fake.getServicePlanVisibilitiesMutex.Unlock()
	fake.GetServicePlanVisibilitiesStub = nil
	if fake.getServicePlanVisibilitiesReturnsOnCall == nil {
		fake.getServicePlanVisibilitiesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServicePlanVisibility
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServicePlanVisibilitiesReturnsOnCall[i] = struct {
		result1 []ccv2.ServicePlanVisibility
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlans(arg1 ...ccv2.Filter) ([]ccv2.ServicePlan, ccv2.Warnings, error) {
	fake.getServicePlansMutex.Lock()
	ret, specificReturn := fake.getServicePlansReturnsOnCall[len(fake.getServicePlansArgsForCall)]
	fake.getServicePlansArgsForCall = append(fake.getServicePlansArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetServicePlans", []interface{}{arg1})
	fake.getServicePlansMutex.Unlock()
	if fake.GetServicePlansStub != nil {
		return fake.GetServicePlansStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServicePlansReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicePlansCallCount() int {
	fake.getServicePlansMutex.RLock()
	defer fake.getServicePlansMutex.RUnlock()
	return len(fake.getServicePlansArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicePlansCalls(stub func(...ccv2.Filter) ([]ccv2.ServicePlan, ccv2.Warnings, error)) {
	fake.getServicePlansMutex.Lock()
	defer fake.getServicePlansMutex.Unlock()
	fake.GetServicePlansStub = stub
}

func (fake *FakeCloudControllerClient) GetServicePlansArgsForCall(i int) []ccv2.Filter {
	fake.getServicePlansMutex.RLock()
	defer fake.getServicePlansMutex.RUnlock()
	argsForCall := fake.getServicePlansArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicePlansReturns(result1 []ccv2.ServicePlan, result2 ccv2.Warnings, result3 error) {
	fake.getServicePlansMutex.Lock()
	defer fake.getServicePlansMutex.Unlock()
	fake.GetServicePlansStub = nil
	fake.getServicePlansReturns = struct {
		result1 []ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicePlansReturnsOnCall(i int, result1 []ccv2.ServicePlan, result2 ccv2.Warnings, result3 error) {
	fake.getServicePlansMutex.Lock()
	defer fake.getServicePlansMutex.Unlock()
	fake.GetServicePlansStub = nil
	if fake.getServicePlansReturnsOnCall == nil {
		fake.getServicePlansReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServicePlan
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServicePlansReturnsOnCall[i] = struct {
		result1 []ccv2.ServicePlan
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServices(arg1 ...ccv2.Filter) ([]ccv2.Service, ccv2.Warnings, error) {
	fake.getServicesMutex.Lock()
	ret, specificReturn := fake.getServicesReturnsOnCall[len(fake.getServicesArgsForCall)]
	fake.getServicesArgsForCall = append(fake.getServicesArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetServices", []interface{}{arg1})
	fake.getServicesMutex.Unlock()
	if fake.GetServicesStub != nil {
		return fake.GetServicesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServicesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetServicesCallCount() int {
	fake.getServicesMutex.RLock()
	defer fake.getServicesMutex.RUnlock()
	return len(fake.getServicesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetServicesCalls(stub func(...ccv2.Filter) ([]ccv2.Service, ccv2.Warnings, error)) {
	fake.getServicesMutex.Lock()
	defer fake.getServicesMutex.Unlock()
	fake.GetServicesStub = stub
}

func (fake *FakeCloudControllerClient) GetServicesArgsForCall(i int) []ccv2.Filter {
	fake.getServicesMutex.RLock()
	defer fake.getServicesMutex.RUnlock()
	argsForCall := fake.getServicesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetServicesReturns(result1 []ccv2.Service, result2 ccv2.Warnings, result3 error) {
	fake.getServicesMutex.Lock()
	defer fake.getServicesMutex.Unlock()
	fake.GetServicesStub = nil
	fake.getServicesReturns = struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServicesReturnsOnCall(i int, result1 []ccv2.Service, result2 ccv2.Warnings, result3 error) {
	fake.getServicesMutex.Lock()
	defer fake.getServicesMutex.Unlock()
	fake.GetServicesStub = nil
	if fake.getServicesReturnsOnCall == nil {
		fake.getServicesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Service
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getServicesReturnsOnCall[i] = struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomain(arg1 string) (ccv2.Domain, ccv2.Warnings, error) {
	fake.getSharedDomainMutex.Lock()
	ret, specificReturn := fake.getSharedDomainReturnsOnCall[len(fake.getSharedDomainArgsForCall)]
	fake.getSharedDomainArgsForCall = append(fake.getSharedDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSharedDomain", []interface{}{arg1})
	fake.getSharedDomainMutex.Unlock()
	if fake.GetSharedDomainStub != nil {
		return fake.GetSharedDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSharedDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSharedDomainCallCount() int {
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	return len(fake.getSharedDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSharedDomainCalls(stub func(string) (ccv2.Domain, ccv2.Warnings, error)) {
	fake.getSharedDomainMutex.Lock()
	defer fake.getSharedDomainMutex.Unlock()
	fake.GetSharedDomainStub = stub
}

func (fake *FakeCloudControllerClient) GetSharedDomainArgsForCall(i int) string {
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	argsForCall := fake.getSharedDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSharedDomainReturns(result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getSharedDomainMutex.Lock()
	defer fake.getSharedDomainMutex.Unlock()
	fake.GetSharedDomainStub = nil
	fake.getSharedDomainReturns = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomainReturnsOnCall(i int, result1 ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getSharedDomainMutex.Lock()
	defer fake.getSharedDomainMutex.Unlock()
	fake.GetSharedDomainStub = nil
	if fake.getSharedDomainReturnsOnCall == nil {
		fake.getSharedDomainReturnsOnCall = make(map[int]struct {
			result1 ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSharedDomainReturnsOnCall[i] = struct {
		result1 ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomains(arg1 ...ccv2.Filter) ([]ccv2.Domain, ccv2.Warnings, error) {
	fake.getSharedDomainsMutex.Lock()
	ret, specificReturn := fake.getSharedDomainsReturnsOnCall[len(fake.getSharedDomainsArgsForCall)]
	fake.getSharedDomainsArgsForCall = append(fake.getSharedDomainsArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetSharedDomains", []interface{}{arg1})
	fake.getSharedDomainsMutex.Unlock()
	if fake.GetSharedDomainsStub != nil {
		return fake.GetSharedDomainsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSharedDomainsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSharedDomainsCallCount() int {
	fake.getSharedDomainsMutex.RLock()
	defer fake.getSharedDomainsMutex.RUnlock()
	return len(fake.getSharedDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSharedDomainsCalls(stub func(...ccv2.Filter) ([]ccv2.Domain, ccv2.Warnings, error)) {
	fake.getSharedDomainsMutex.Lock()
	defer fake.getSharedDomainsMutex.Unlock()
	fake.GetSharedDomainsStub = stub
}

func (fake *FakeCloudControllerClient) GetSharedDomainsArgsForCall(i int) []ccv2.Filter {
	fake.getSharedDomainsMutex.RLock()
	defer fake.getSharedDomainsMutex.RUnlock()
	argsForCall := fake.getSharedDomainsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSharedDomainsReturns(result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getSharedDomainsMutex.Lock()
	defer fake.getSharedDomainsMutex.Unlock()
	fake.GetSharedDomainsStub = nil
	fake.getSharedDomainsReturns = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSharedDomainsReturnsOnCall(i int, result1 []ccv2.Domain, result2 ccv2.Warnings, result3 error) {
	fake.getSharedDomainsMutex.Lock()
	defer fake.getSharedDomainsMutex.Unlock()
	fake.GetSharedDomainsStub = nil
	if fake.getSharedDomainsReturnsOnCall == nil {
		fake.getSharedDomainsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Domain
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSharedDomainsReturnsOnCall[i] = struct {
		result1 []ccv2.Domain
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaDefinition(arg1 string) (ccv2.SpaceQuota, ccv2.Warnings, error) {
	fake.getSpaceQuotaDefinitionMutex.Lock()
	ret, specificReturn := fake.getSpaceQuotaDefinitionReturnsOnCall[len(fake.getSpaceQuotaDefinitionArgsForCall)]
	fake.getSpaceQuotaDefinitionArgsForCall = append(fake.getSpaceQuotaDefinitionArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSpaceQuotaDefinition", []interface{}{arg1})
	fake.getSpaceQuotaDefinitionMutex.Unlock()
	if fake.GetSpaceQuotaDefinitionStub != nil {
		return fake.GetSpaceQuotaDefinitionStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceQuotaDefinitionReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaDefinitionCallCount() int {
	fake.getSpaceQuotaDefinitionMutex.RLock()
	defer fake.getSpaceQuotaDefinitionMutex.RUnlock()
	return len(fake.getSpaceQuotaDefinitionArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaDefinitionCalls(stub func(string) (ccv2.SpaceQuota, ccv2.Warnings, error)) {
	fake.getSpaceQuotaDefinitionMutex.Lock()
	defer fake.getSpaceQuotaDefinitionMutex.Unlock()
	fake.GetSpaceQuotaDefinitionStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaDefinitionArgsForCall(i int) string {
	fake.getSpaceQuotaDefinitionMutex.RLock()
	defer fake.getSpaceQuotaDefinitionMutex.RUnlock()
	argsForCall := fake.getSpaceQuotaDefinitionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaDefinitionReturns(result1 ccv2.SpaceQuota, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceQuotaDefinitionMutex.Lock()
	defer fake.getSpaceQuotaDefinitionMutex.Unlock()
	fake.GetSpaceQuotaDefinitionStub = nil
	fake.getSpaceQuotaDefinitionReturns = struct {
		result1 ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotaDefinitionReturnsOnCall(i int, result1 ccv2.SpaceQuota, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceQuotaDefinitionMutex.Lock()
	defer fake.getSpaceQuotaDefinitionMutex.Unlock()
	fake.GetSpaceQuotaDefinitionStub = nil
	if fake.getSpaceQuotaDefinitionReturnsOnCall == nil {
		fake.getSpaceQuotaDefinitionReturnsOnCall = make(map[int]struct {
			result1 ccv2.SpaceQuota
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotaDefinitionReturnsOnCall[i] = struct {
		result1 ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotas(arg1 string) ([]ccv2.SpaceQuota, ccv2.Warnings, error) {
	fake.getSpaceQuotasMutex.Lock()
	ret, specificReturn := fake.getSpaceQuotasReturnsOnCall[len(fake.getSpaceQuotasArgsForCall)]
	fake.getSpaceQuotasArgsForCall = append(fake.getSpaceQuotasArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSpaceQuotas", []interface{}{arg1})
	fake.getSpaceQuotasMutex.Unlock()
	if fake.GetSpaceQuotasStub != nil {
		return fake.GetSpaceQuotasStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceQuotasReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasCallCount() int {
	fake.getSpaceQuotasMutex.RLock()
	defer fake.getSpaceQuotasMutex.RUnlock()
	return len(fake.getSpaceQuotasArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasCalls(stub func(string) ([]ccv2.SpaceQuota, ccv2.Warnings, error)) {
	fake.getSpaceQuotasMutex.Lock()
	defer fake.getSpaceQuotasMutex.Unlock()
	fake.GetSpaceQuotasStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasArgsForCall(i int) string {
	fake.getSpaceQuotasMutex.RLock()
	defer fake.getSpaceQuotasMutex.RUnlock()
	argsForCall := fake.getSpaceQuotasArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasReturns(result1 []ccv2.SpaceQuota, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceQuotasMutex.Lock()
	defer fake.getSpaceQuotasMutex.Unlock()
	fake.GetSpaceQuotasStub = nil
	fake.getSpaceQuotasReturns = struct {
		result1 []ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceQuotasReturnsOnCall(i int, result1 []ccv2.SpaceQuota, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceQuotasMutex.Lock()
	defer fake.getSpaceQuotasMutex.Unlock()
	fake.GetSpaceQuotasStub = nil
	if fake.getSpaceQuotasReturnsOnCall == nil {
		fake.getSpaceQuotasReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SpaceQuota
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotasReturnsOnCall[i] = struct {
		result1 []ccv2.SpaceQuota
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceRoutes(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error) {
	fake.getSpaceRoutesMutex.Lock()
	ret, specificReturn := fake.getSpaceRoutesReturnsOnCall[len(fake.getSpaceRoutesArgsForCall)]
	fake.getSpaceRoutesArgsForCall = append(fake.getSpaceRoutesArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceRoutes", []interface{}{arg1, arg2})
	fake.getSpaceRoutesMutex.Unlock()
	if fake.GetSpaceRoutesStub != nil {
		return fake.GetSpaceRoutesStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceRoutesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesCallCount() int {
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	return len(fake.getSpaceRoutesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesCalls(stub func(string, ...ccv2.Filter) ([]ccv2.Route, ccv2.Warnings, error)) {
	fake.getSpaceRoutesMutex.Lock()
	defer fake.getSpaceRoutesMutex.Unlock()
	fake.GetSpaceRoutesStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	argsForCall := fake.getSpaceRoutesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesReturns(result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceRoutesMutex.Lock()
	defer fake.getSpaceRoutesMutex.Unlock()
	fake.GetSpaceRoutesStub = nil
	fake.getSpaceRoutesReturns = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceRoutesReturnsOnCall(i int, result1 []ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceRoutesMutex.Lock()
	defer fake.getSpaceRoutesMutex.Unlock()
	fake.GetSpaceRoutesStub = nil
	if fake.getSpaceRoutesReturnsOnCall == nil {
		fake.getSpaceRoutesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceRoutesReturnsOnCall[i] = struct {
		result1 []ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceSecurityGroups(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error) {
	fake.getSpaceSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getSpaceSecurityGroupsReturnsOnCall[len(fake.getSpaceSecurityGroupsArgsForCall)]
	fake.getSpaceSecurityGroupsArgsForCall = append(fake.getSpaceSecurityGroupsArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceSecurityGroups", []interface{}{arg1, arg2})
	fake.getSpaceSecurityGroupsMutex.Unlock()
	if fake.GetSpaceSecurityGroupsStub != nil {
		return fake.GetSpaceSecurityGroupsStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceSecurityGroupsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceSecurityGroupsCallCount() int {
	fake.getSpaceSecurityGroupsMutex.RLock()
	defer fake.getSpaceSecurityGroupsMutex.RUnlock()
	return len(fake.getSpaceSecurityGroupsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceSecurityGroupsCalls(stub func(string, ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error)) {
	fake.getSpaceSecurityGroupsMutex.Lock()
	defer fake.getSpaceSecurityGroupsMutex.Unlock()
	fake.GetSpaceSecurityGroupsStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceSecurityGroupsArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getSpaceSecurityGroupsMutex.RLock()
	defer fake.getSpaceSecurityGroupsMutex.RUnlock()
	argsForCall := fake.getSpaceSecurityGroupsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetSpaceSecurityGroupsReturns(result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceSecurityGroupsMutex.Lock()
	defer fake.getSpaceSecurityGroupsMutex.Unlock()
	fake.GetSpaceSecurityGroupsStub = nil
	fake.getSpaceSecurityGroupsReturns = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceSecurityGroupsReturnsOnCall(i int, result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceSecurityGroupsMutex.Lock()
	defer fake.getSpaceSecurityGroupsMutex.Unlock()
	fake.GetSpaceSecurityGroupsStub = nil
	if fake.getSpaceSecurityGroupsReturnsOnCall == nil {
		fake.getSpaceSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SecurityGroup
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceSecurityGroupsReturnsOnCall[i] = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstances(arg1 string, arg2 bool, arg3 ...ccv2.Filter) ([]ccv2.ServiceInstance, ccv2.Warnings, error) {
	fake.getSpaceServiceInstancesMutex.Lock()
	ret, specificReturn := fake.getSpaceServiceInstancesReturnsOnCall[len(fake.getSpaceServiceInstancesArgsForCall)]
	fake.getSpaceServiceInstancesArgsForCall = append(fake.getSpaceServiceInstancesArgsForCall, struct {
		arg1 string
		arg2 bool
		arg3 []ccv2.Filter
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetSpaceServiceInstances", []interface{}{arg1, arg2, arg3})
	fake.getSpaceServiceInstancesMutex.Unlock()
	if fake.GetSpaceServiceInstancesStub != nil {
		return fake.GetSpaceServiceInstancesStub(arg1, arg2, arg3...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceServiceInstancesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesCallCount() int {
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	return len(fake.getSpaceServiceInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesCalls(stub func(string, bool, ...ccv2.Filter) ([]ccv2.ServiceInstance, ccv2.Warnings, error)) {
	fake.getSpaceServiceInstancesMutex.Lock()
	defer fake.getSpaceServiceInstancesMutex.Unlock()
	fake.GetSpaceServiceInstancesStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesArgsForCall(i int) (string, bool, []ccv2.Filter) {
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	argsForCall := fake.getSpaceServiceInstancesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesReturns(result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceServiceInstancesMutex.Lock()
	defer fake.getSpaceServiceInstancesMutex.Unlock()
	fake.GetSpaceServiceInstancesStub = nil
	fake.getSpaceServiceInstancesReturns = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceServiceInstancesReturnsOnCall(i int, result1 []ccv2.ServiceInstance, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceServiceInstancesMutex.Lock()
	defer fake.getSpaceServiceInstancesMutex.Unlock()
	fake.GetSpaceServiceInstancesStub = nil
	if fake.getSpaceServiceInstancesReturnsOnCall == nil {
		fake.getSpaceServiceInstancesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceInstance
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceServiceInstancesReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceInstance
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceServices(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.Service, ccv2.Warnings, error) {
	fake.getSpaceServicesMutex.Lock()
	ret, specificReturn := fake.getSpaceServicesReturnsOnCall[len(fake.getSpaceServicesArgsForCall)]
	fake.getSpaceServicesArgsForCall = append(fake.getSpaceServicesArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceServices", []interface{}{arg1, arg2})
	fake.getSpaceServicesMutex.Unlock()
	if fake.GetSpaceServicesStub != nil {
		return fake.GetSpaceServicesStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceServicesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceServicesCallCount() int {
	fake.getSpaceServicesMutex.RLock()
	defer fake.getSpaceServicesMutex.RUnlock()
	return len(fake.getSpaceServicesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceServicesCalls(stub func(string, ...ccv2.Filter) ([]ccv2.Service, ccv2.Warnings, error)) {
	fake.getSpaceServicesMutex.Lock()
	defer fake.getSpaceServicesMutex.Unlock()
	fake.GetSpaceServicesStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceServicesArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getSpaceServicesMutex.RLock()
	defer fake.getSpaceServicesMutex.RUnlock()
	argsForCall := fake.getSpaceServicesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetSpaceServicesReturns(result1 []ccv2.Service, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceServicesMutex.Lock()
	defer fake.getSpaceServicesMutex.Unlock()
	fake.GetSpaceServicesStub = nil
	fake.getSpaceServicesReturns = struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceServicesReturnsOnCall(i int, result1 []ccv2.Service, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceServicesMutex.Lock()
	defer fake.getSpaceServicesMutex.Unlock()
	fake.GetSpaceServicesStub = nil
	if fake.getSpaceServicesReturnsOnCall == nil {
		fake.getSpaceServicesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Service
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceServicesReturnsOnCall[i] = struct {
		result1 []ccv2.Service
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroups(arg1 string, arg2 ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error) {
	fake.getSpaceStagingSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getSpaceStagingSecurityGroupsReturnsOnCall[len(fake.getSpaceStagingSecurityGroupsArgsForCall)]
	fake.getSpaceStagingSecurityGroupsArgsForCall = append(fake.getSpaceStagingSecurityGroupsArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Filter
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceStagingSecurityGroups", []interface{}{arg1, arg2})
	fake.getSpaceStagingSecurityGroupsMutex.Unlock()
	if fake.GetSpaceStagingSecurityGroupsStub != nil {
		return fake.GetSpaceStagingSecurityGroupsStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceStagingSecurityGroupsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsCallCount() int {
	fake.getSpaceStagingSecurityGroupsMutex.RLock()
	defer fake.getSpaceStagingSecurityGroupsMutex.RUnlock()
	return len(fake.getSpaceStagingSecurityGroupsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsCalls(stub func(string, ...ccv2.Filter) ([]ccv2.SecurityGroup, ccv2.Warnings, error)) {
	fake.getSpaceStagingSecurityGroupsMutex.Lock()
	defer fake.getSpaceStagingSecurityGroupsMutex.Unlock()
	fake.GetSpaceStagingSecurityGroupsStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsArgsForCall(i int) (string, []ccv2.Filter) {
	fake.getSpaceStagingSecurityGroupsMutex.RLock()
	defer fake.getSpaceStagingSecurityGroupsMutex.RUnlock()
	argsForCall := fake.getSpaceStagingSecurityGroupsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsReturns(result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceStagingSecurityGroupsMutex.Lock()
	defer fake.getSpaceStagingSecurityGroupsMutex.Unlock()
	fake.GetSpaceStagingSecurityGroupsStub = nil
	fake.getSpaceStagingSecurityGroupsReturns = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceStagingSecurityGroupsReturnsOnCall(i int, result1 []ccv2.SecurityGroup, result2 ccv2.Warnings, result3 error) {
	fake.getSpaceStagingSecurityGroupsMutex.Lock()
	defer fake.getSpaceStagingSecurityGroupsMutex.Unlock()
	fake.GetSpaceStagingSecurityGroupsStub = nil
	if fake.getSpaceStagingSecurityGroupsReturnsOnCall == nil {
		fake.getSpaceStagingSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.SecurityGroup
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpaceStagingSecurityGroupsReturnsOnCall[i] = struct {
		result1 []ccv2.SecurityGroup
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaces(arg1 ...ccv2.Filter) ([]ccv2.Space, ccv2.Warnings, error) {
	fake.getSpacesMutex.Lock()
	ret, specificReturn := fake.getSpacesReturnsOnCall[len(fake.getSpacesArgsForCall)]
	fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetSpaces", []interface{}{arg1})
	fake.getSpacesMutex.Unlock()
	if fake.GetSpacesStub != nil {
		return fake.GetSpacesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpacesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpacesCallCount() int {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	return len(fake.getSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpacesCalls(stub func(...ccv2.Filter) ([]ccv2.Space, ccv2.Warnings, error)) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = stub
}

func (fake *FakeCloudControllerClient) GetSpacesArgsForCall(i int) []ccv2.Filter {
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	argsForCall := fake.getSpacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpacesReturns(result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = nil
	fake.getSpacesReturns = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpacesReturnsOnCall(i int, result1 []ccv2.Space, result2 ccv2.Warnings, result3 error) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = nil
	if fake.getSpacesReturnsOnCall == nil {
		fake.getSpacesReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Space
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getSpacesReturnsOnCall[i] = struct {
		result1 []ccv2.Space
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStack(arg1 string) (ccv2.Stack, ccv2.Warnings, error) {
	fake.getStackMutex.Lock()
	ret, specificReturn := fake.getStackReturnsOnCall[len(fake.getStackArgsForCall)]
	fake.getStackArgsForCall = append(fake.getStackArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetStack", []interface{}{arg1})
	fake.getStackMutex.Unlock()
	if fake.GetStackStub != nil {
		return fake.GetStackStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getStackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetStackCallCount() int {
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	return len(fake.getStackArgsForCall)
}

func (fake *FakeCloudControllerClient) GetStackCalls(stub func(string) (ccv2.Stack, ccv2.Warnings, error)) {
	fake.getStackMutex.Lock()
	defer fake.getStackMutex.Unlock()
	fake.GetStackStub = stub
}

func (fake *FakeCloudControllerClient) GetStackArgsForCall(i int) string {
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	argsForCall := fake.getStackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetStackReturns(result1 ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.getStackMutex.Lock()
	defer fake.getStackMutex.Unlock()
	fake.GetStackStub = nil
	fake.getStackReturns = struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStackReturnsOnCall(i int, result1 ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.getStackMutex.Lock()
	defer fake.getStackMutex.Unlock()
	fake.GetStackStub = nil
	if fake.getStackReturnsOnCall == nil {
		fake.getStackReturnsOnCall = make(map[int]struct {
			result1 ccv2.Stack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getStackReturnsOnCall[i] = struct {
		result1 ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStacks(arg1 ...ccv2.Filter) ([]ccv2.Stack, ccv2.Warnings, error) {
	fake.getStacksMutex.Lock()
	ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)]
	fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct {
		arg1 []ccv2.Filter
	}{arg1})
	fake.recordInvocation("GetStacks", []interface{}{arg1})
	fake.getStacksMutex.Unlock()
	if fake.GetStacksStub != nil {
		return fake.GetStacksStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getStacksReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetStacksCallCount() int {
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	return len(fake.getStacksArgsForCall)
}

func (fake *FakeCloudControllerClient) GetStacksCalls(stub func(...ccv2.Filter) ([]ccv2.Stack, ccv2.Warnings, error)) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = stub
}

func (fake *FakeCloudControllerClient) GetStacksArgsForCall(i int) []ccv2.Filter {
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	argsForCall := fake.getStacksArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetStacksReturns(result1 []ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = nil
	fake.getStacksReturns = struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetStacksReturnsOnCall(i int, result1 []ccv2.Stack, result2 ccv2.Warnings, result3 error) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = nil
	if fake.getStacksReturnsOnCall == nil {
		fake.getStacksReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Stack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getStacksReturnsOnCall[i] = struct {
		result1 []ccv2.Stack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetUserProvidedServiceInstanceServiceBindings(arg1 string) ([]ccv2.ServiceBinding, ccv2.Warnings, error) {
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.Lock()
	ret, specificReturn := fake.getUserProvidedServiceInstanceServiceBindingsReturnsOnCall[len(fake.getUserProvidedServiceInstanceServiceBindingsArgsForCall)]
	fake.getUserProvidedServiceInstanceServiceBindingsArgsForCall = append(fake.getUserProvidedServiceInstanceServiceBindingsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetUserProvidedServiceInstanceServiceBindings", []interface{}{arg1})
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.Unlock()
	if fake.GetUserProvidedServiceInstanceServiceBindingsStub != nil {
		return fake.GetUserProvidedServiceInstanceServiceBindingsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getUserProvidedServiceInstanceServiceBindingsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetUserProvidedServiceInstanceServiceBindingsCallCount() int {
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.RLock()
	defer fake.getUserProvidedServiceInstanceServiceBindingsMutex.RUnlock()
	return len(fake.getUserProvidedServiceInstanceServiceBindingsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetUserProvidedServiceInstanceServiceBindingsCalls(stub func(string) ([]ccv2.ServiceBinding, ccv2.Warnings, error)) {
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.Lock()
	defer fake.getUserProvidedServiceInstanceServiceBindingsMutex.Unlock()
	fake.GetUserProvidedServiceInstanceServiceBindingsStub = stub
}

func (fake *FakeCloudControllerClient) GetUserProvidedServiceInstanceServiceBindingsArgsForCall(i int) string {
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.RLock()
	defer fake.getUserProvidedServiceInstanceServiceBindingsMutex.RUnlock()
	argsForCall := fake.getUserProvidedServiceInstanceServiceBindingsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetUserProvidedServiceInstanceServiceBindingsReturns(result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.Lock()
	defer fake.getUserProvidedServiceInstanceServiceBindingsMutex.Unlock()
	fake.GetUserProvidedServiceInstanceServiceBindingsStub = nil
	fake.getUserProvidedServiceInstanceServiceBindingsReturns = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetUserProvidedServiceInstanceServiceBindingsReturnsOnCall(i int, result1 []ccv2.ServiceBinding, result2 ccv2.Warnings, result3 error) {
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.Lock()
	defer fake.getUserProvidedServiceInstanceServiceBindingsMutex.Unlock()
	fake.GetUserProvidedServiceInstanceServiceBindingsStub = nil
	if fake.getUserProvidedServiceInstanceServiceBindingsReturnsOnCall == nil {
		fake.getUserProvidedServiceInstanceServiceBindingsReturnsOnCall = make(map[int]struct {
			result1 []ccv2.ServiceBinding
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.getUserProvidedServiceInstanceServiceBindingsReturnsOnCall[i] = struct {
		result1 []ccv2.ServiceBinding
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

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

func (fake *FakeCloudControllerClient) 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 *FakeCloudControllerClient) PollJob(arg1 ccv2.Job) (ccv2.Warnings, error) {
	fake.pollJobMutex.Lock()
	ret, specificReturn := fake.pollJobReturnsOnCall[len(fake.pollJobArgsForCall)]
	fake.pollJobArgsForCall = append(fake.pollJobArgsForCall, struct {
		arg1 ccv2.Job
	}{arg1})
	fake.recordInvocation("PollJob", []interface{}{arg1})
	fake.pollJobMutex.Unlock()
	if fake.PollJobStub != nil {
		return fake.PollJobStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.pollJobReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) PollJobCallCount() int {
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	return len(fake.pollJobArgsForCall)
}

func (fake *FakeCloudControllerClient) PollJobCalls(stub func(ccv2.Job) (ccv2.Warnings, error)) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = stub
}

func (fake *FakeCloudControllerClient) PollJobArgsForCall(i int) ccv2.Job {
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	argsForCall := fake.pollJobArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) PollJobReturns(result1 ccv2.Warnings, result2 error) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = nil
	fake.pollJobReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) PollJobReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = nil
	if fake.pollJobReturnsOnCall == nil {
		fake.pollJobReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.pollJobReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) RestageApplication(arg1 ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.restageApplicationMutex.Lock()
	ret, specificReturn := fake.restageApplicationReturnsOnCall[len(fake.restageApplicationArgsForCall)]
	fake.restageApplicationArgsForCall = append(fake.restageApplicationArgsForCall, struct {
		arg1 ccv2.Application
	}{arg1})
	fake.recordInvocation("RestageApplication", []interface{}{arg1})
	fake.restageApplicationMutex.Unlock()
	if fake.RestageApplicationStub != nil {
		return fake.RestageApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.restageApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) RestageApplicationCallCount() int {
	fake.restageApplicationMutex.RLock()
	defer fake.restageApplicationMutex.RUnlock()
	return len(fake.restageApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) RestageApplicationCalls(stub func(ccv2.Application) (ccv2.Application, ccv2.Warnings, error)) {
	fake.restageApplicationMutex.Lock()
	defer fake.restageApplicationMutex.Unlock()
	fake.RestageApplicationStub = stub
}

func (fake *FakeCloudControllerClient) RestageApplicationArgsForCall(i int) ccv2.Application {
	fake.restageApplicationMutex.RLock()
	defer fake.restageApplicationMutex.RUnlock()
	argsForCall := fake.restageApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) RestageApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.restageApplicationMutex.Lock()
	defer fake.restageApplicationMutex.Unlock()
	fake.RestageApplicationStub = nil
	fake.restageApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) RestageApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.restageApplicationMutex.Lock()
	defer fake.restageApplicationMutex.Unlock()
	fake.RestageApplicationStub = nil
	if fake.restageApplicationReturnsOnCall == nil {
		fake.restageApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.restageApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

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

func (fake *FakeCloudControllerClient) 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 *FakeCloudControllerClient) SetSpaceQuota(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.setSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.setSpaceQuotaReturnsOnCall[len(fake.setSpaceQuotaArgsForCall)]
	fake.setSpaceQuotaArgsForCall = append(fake.setSpaceQuotaArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("SetSpaceQuota", []interface{}{arg1, arg2})
	fake.setSpaceQuotaMutex.Unlock()
	if fake.SetSpaceQuotaStub != nil {
		return fake.SetSpaceQuotaStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setSpaceQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) SetSpaceQuotaCallCount() int {
	fake.setSpaceQuotaMutex.RLock()
	defer fake.setSpaceQuotaMutex.RUnlock()
	return len(fake.setSpaceQuotaArgsForCall)
}

func (fake *FakeCloudControllerClient) SetSpaceQuotaCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.setSpaceQuotaMutex.Lock()
	defer fake.setSpaceQuotaMutex.Unlock()
	fake.SetSpaceQuotaStub = stub
}

func (fake *FakeCloudControllerClient) SetSpaceQuotaArgsForCall(i int) (string, string) {
	fake.setSpaceQuotaMutex.RLock()
	defer fake.setSpaceQuotaMutex.RUnlock()
	argsForCall := fake.setSpaceQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) SetSpaceQuotaReturns(result1 ccv2.Warnings, result2 error) {
	fake.setSpaceQuotaMutex.Lock()
	defer fake.setSpaceQuotaMutex.Unlock()
	fake.SetSpaceQuotaStub = nil
	fake.setSpaceQuotaReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) SetSpaceQuotaReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.setSpaceQuotaMutex.Lock()
	defer fake.setSpaceQuotaMutex.Unlock()
	fake.SetSpaceQuotaStub = nil
	if fake.setSpaceQuotaReturnsOnCall == nil {
		fake.setSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.setSpaceQuotaReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) TargetCF(arg1 ccv2.TargetSettings) (ccv2.Warnings, error) {
	fake.targetCFMutex.Lock()
	ret, specificReturn := fake.targetCFReturnsOnCall[len(fake.targetCFArgsForCall)]
	fake.targetCFArgsForCall = append(fake.targetCFArgsForCall, struct {
		arg1 ccv2.TargetSettings
	}{arg1})
	fake.recordInvocation("TargetCF", []interface{}{arg1})
	fake.targetCFMutex.Unlock()
	if fake.TargetCFStub != nil {
		return fake.TargetCFStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.targetCFReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) TargetCFCallCount() int {
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	return len(fake.targetCFArgsForCall)
}

func (fake *FakeCloudControllerClient) TargetCFCalls(stub func(ccv2.TargetSettings) (ccv2.Warnings, error)) {
	fake.targetCFMutex.Lock()
	defer fake.targetCFMutex.Unlock()
	fake.TargetCFStub = stub
}

func (fake *FakeCloudControllerClient) TargetCFArgsForCall(i int) ccv2.TargetSettings {
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	argsForCall := fake.targetCFArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) TargetCFReturns(result1 ccv2.Warnings, result2 error) {
	fake.targetCFMutex.Lock()
	defer fake.targetCFMutex.Unlock()
	fake.TargetCFStub = nil
	fake.targetCFReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) TargetCFReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.targetCFMutex.Lock()
	defer fake.targetCFMutex.Unlock()
	fake.TargetCFStub = nil
	if fake.targetCFReturnsOnCall == nil {
		fake.targetCFReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.targetCFReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) TokenEndpoint() string {
	fake.tokenEndpointMutex.Lock()
	ret, specificReturn := fake.tokenEndpointReturnsOnCall[len(fake.tokenEndpointArgsForCall)]
	fake.tokenEndpointArgsForCall = append(fake.tokenEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("TokenEndpoint", []interface{}{})
	fake.tokenEndpointMutex.Unlock()
	if fake.TokenEndpointStub != nil {
		return fake.TokenEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.tokenEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) TokenEndpointCallCount() int {
	fake.tokenEndpointMutex.RLock()
	defer fake.tokenEndpointMutex.RUnlock()
	return len(fake.tokenEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) TokenEndpointCalls(stub func() string) {
	fake.tokenEndpointMutex.Lock()
	defer fake.tokenEndpointMutex.Unlock()
	fake.TokenEndpointStub = stub
}

func (fake *FakeCloudControllerClient) TokenEndpointReturns(result1 string) {
	fake.tokenEndpointMutex.Lock()
	defer fake.tokenEndpointMutex.Unlock()
	fake.TokenEndpointStub = nil
	fake.tokenEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) TokenEndpointReturnsOnCall(i int, result1 string) {
	fake.tokenEndpointMutex.Lock()
	defer fake.tokenEndpointMutex.Unlock()
	fake.TokenEndpointStub = nil
	if fake.tokenEndpointReturnsOnCall == nil {
		fake.tokenEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.tokenEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) UpdateApplication(arg1 ccv2.Application) (ccv2.Application, ccv2.Warnings, error) {
	fake.updateApplicationMutex.Lock()
	ret, specificReturn := fake.updateApplicationReturnsOnCall[len(fake.updateApplicationArgsForCall)]
	fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, struct {
		arg1 ccv2.Application
	}{arg1})
	fake.recordInvocation("UpdateApplication", []interface{}{arg1})
	fake.updateApplicationMutex.Unlock()
	if fake.UpdateApplicationStub != nil {
		return fake.UpdateApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationCallCount() int {
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	return len(fake.updateApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationCalls(stub func(ccv2.Application) (ccv2.Application, ccv2.Warnings, error)) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationArgsForCall(i int) ccv2.Application {
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	argsForCall := fake.updateApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationReturns(result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = nil
	fake.updateApplicationReturns = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationReturnsOnCall(i int, result1 ccv2.Application, result2 ccv2.Warnings, result3 error) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = nil
	if fake.updateApplicationReturnsOnCall == nil {
		fake.updateApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Application
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.updateApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Application
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateBuildpack(arg1 ccv2.Buildpack) (ccv2.Buildpack, ccv2.Warnings, error) {
	fake.updateBuildpackMutex.Lock()
	ret, specificReturn := fake.updateBuildpackReturnsOnCall[len(fake.updateBuildpackArgsForCall)]
	fake.updateBuildpackArgsForCall = append(fake.updateBuildpackArgsForCall, struct {
		arg1 ccv2.Buildpack
	}{arg1})
	fake.recordInvocation("UpdateBuildpack", []interface{}{arg1})
	fake.updateBuildpackMutex.Unlock()
	if fake.UpdateBuildpackStub != nil {
		return fake.UpdateBuildpackStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateBuildpackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateBuildpackCallCount() int {
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	return len(fake.updateBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateBuildpackCalls(stub func(ccv2.Buildpack) (ccv2.Buildpack, ccv2.Warnings, error)) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) UpdateBuildpackArgsForCall(i int) ccv2.Buildpack {
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	argsForCall := fake.updateBuildpackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateBuildpackReturns(result1 ccv2.Buildpack, result2 ccv2.Warnings, result3 error) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = nil
	fake.updateBuildpackReturns = struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateBuildpackReturnsOnCall(i int, result1 ccv2.Buildpack, result2 ccv2.Warnings, result3 error) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = nil
	if fake.updateBuildpackReturnsOnCall == nil {
		fake.updateBuildpackReturnsOnCall = make(map[int]struct {
			result1 ccv2.Buildpack
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.updateBuildpackReturnsOnCall[i] = struct {
		result1 ccv2.Buildpack
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManager(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateOrganizationManagerMutex.Lock()
	ret, specificReturn := fake.updateOrganizationManagerReturnsOnCall[len(fake.updateOrganizationManagerArgsForCall)]
	fake.updateOrganizationManagerArgsForCall = append(fake.updateOrganizationManagerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrganizationManager", []interface{}{arg1, arg2})
	fake.updateOrganizationManagerMutex.Unlock()
	if fake.UpdateOrganizationManagerStub != nil {
		return fake.UpdateOrganizationManagerStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrganizationManagerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerCallCount() int {
	fake.updateOrganizationManagerMutex.RLock()
	defer fake.updateOrganizationManagerMutex.RUnlock()
	return len(fake.updateOrganizationManagerArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateOrganizationManagerMutex.Lock()
	defer fake.updateOrganizationManagerMutex.Unlock()
	fake.UpdateOrganizationManagerStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerArgsForCall(i int) (string, string) {
	fake.updateOrganizationManagerMutex.RLock()
	defer fake.updateOrganizationManagerMutex.RUnlock()
	argsForCall := fake.updateOrganizationManagerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationManagerMutex.Lock()
	defer fake.updateOrganizationManagerMutex.Unlock()
	fake.UpdateOrganizationManagerStub = nil
	fake.updateOrganizationManagerReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationManagerMutex.Lock()
	defer fake.updateOrganizationManagerMutex.Unlock()
	fake.UpdateOrganizationManagerStub = nil
	if fake.updateOrganizationManagerReturnsOnCall == nil {
		fake.updateOrganizationManagerReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateOrganizationManagerReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerByUsername(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateOrganizationManagerByUsernameMutex.Lock()
	ret, specificReturn := fake.updateOrganizationManagerByUsernameReturnsOnCall[len(fake.updateOrganizationManagerByUsernameArgsForCall)]
	fake.updateOrganizationManagerByUsernameArgsForCall = append(fake.updateOrganizationManagerByUsernameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrganizationManagerByUsername", []interface{}{arg1, arg2})
	fake.updateOrganizationManagerByUsernameMutex.Unlock()
	if fake.UpdateOrganizationManagerByUsernameStub != nil {
		return fake.UpdateOrganizationManagerByUsernameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrganizationManagerByUsernameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerByUsernameCallCount() int {
	fake.updateOrganizationManagerByUsernameMutex.RLock()
	defer fake.updateOrganizationManagerByUsernameMutex.RUnlock()
	return len(fake.updateOrganizationManagerByUsernameArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerByUsernameCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateOrganizationManagerByUsernameMutex.Lock()
	defer fake.updateOrganizationManagerByUsernameMutex.Unlock()
	fake.UpdateOrganizationManagerByUsernameStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerByUsernameArgsForCall(i int) (string, string) {
	fake.updateOrganizationManagerByUsernameMutex.RLock()
	defer fake.updateOrganizationManagerByUsernameMutex.RUnlock()
	argsForCall := fake.updateOrganizationManagerByUsernameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerByUsernameReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationManagerByUsernameMutex.Lock()
	defer fake.updateOrganizationManagerByUsernameMutex.Unlock()
	fake.UpdateOrganizationManagerByUsernameStub = nil
	fake.updateOrganizationManagerByUsernameReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationManagerByUsernameReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationManagerByUsernameMutex.Lock()
	defer fake.updateOrganizationManagerByUsernameMutex.Unlock()
	fake.UpdateOrganizationManagerByUsernameStub = nil
	if fake.updateOrganizationManagerByUsernameReturnsOnCall == nil {
		fake.updateOrganizationManagerByUsernameReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateOrganizationManagerByUsernameReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUser(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateOrganizationUserMutex.Lock()
	ret, specificReturn := fake.updateOrganizationUserReturnsOnCall[len(fake.updateOrganizationUserArgsForCall)]
	fake.updateOrganizationUserArgsForCall = append(fake.updateOrganizationUserArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrganizationUser", []interface{}{arg1, arg2})
	fake.updateOrganizationUserMutex.Unlock()
	if fake.UpdateOrganizationUserStub != nil {
		return fake.UpdateOrganizationUserStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrganizationUserReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserCallCount() int {
	fake.updateOrganizationUserMutex.RLock()
	defer fake.updateOrganizationUserMutex.RUnlock()
	return len(fake.updateOrganizationUserArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateOrganizationUserMutex.Lock()
	defer fake.updateOrganizationUserMutex.Unlock()
	fake.UpdateOrganizationUserStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserArgsForCall(i int) (string, string) {
	fake.updateOrganizationUserMutex.RLock()
	defer fake.updateOrganizationUserMutex.RUnlock()
	argsForCall := fake.updateOrganizationUserArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationUserMutex.Lock()
	defer fake.updateOrganizationUserMutex.Unlock()
	fake.UpdateOrganizationUserStub = nil
	fake.updateOrganizationUserReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationUserMutex.Lock()
	defer fake.updateOrganizationUserMutex.Unlock()
	fake.UpdateOrganizationUserStub = nil
	if fake.updateOrganizationUserReturnsOnCall == nil {
		fake.updateOrganizationUserReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateOrganizationUserReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserByUsername(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateOrganizationUserByUsernameMutex.Lock()
	ret, specificReturn := fake.updateOrganizationUserByUsernameReturnsOnCall[len(fake.updateOrganizationUserByUsernameArgsForCall)]
	fake.updateOrganizationUserByUsernameArgsForCall = append(fake.updateOrganizationUserByUsernameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrganizationUserByUsername", []interface{}{arg1, arg2})
	fake.updateOrganizationUserByUsernameMutex.Unlock()
	if fake.UpdateOrganizationUserByUsernameStub != nil {
		return fake.UpdateOrganizationUserByUsernameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrganizationUserByUsernameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserByUsernameCallCount() int {
	fake.updateOrganizationUserByUsernameMutex.RLock()
	defer fake.updateOrganizationUserByUsernameMutex.RUnlock()
	return len(fake.updateOrganizationUserByUsernameArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserByUsernameCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateOrganizationUserByUsernameMutex.Lock()
	defer fake.updateOrganizationUserByUsernameMutex.Unlock()
	fake.UpdateOrganizationUserByUsernameStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserByUsernameArgsForCall(i int) (string, string) {
	fake.updateOrganizationUserByUsernameMutex.RLock()
	defer fake.updateOrganizationUserByUsernameMutex.RUnlock()
	argsForCall := fake.updateOrganizationUserByUsernameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserByUsernameReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationUserByUsernameMutex.Lock()
	defer fake.updateOrganizationUserByUsernameMutex.Unlock()
	fake.UpdateOrganizationUserByUsernameStub = nil
	fake.updateOrganizationUserByUsernameReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationUserByUsernameReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateOrganizationUserByUsernameMutex.Lock()
	defer fake.updateOrganizationUserByUsernameMutex.Unlock()
	fake.UpdateOrganizationUserByUsernameStub = nil
	if fake.updateOrganizationUserByUsernameReturnsOnCall == nil {
		fake.updateOrganizationUserByUsernameReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateOrganizationUserByUsernameReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateResourceMatch(arg1 []ccv2.Resource) ([]ccv2.Resource, ccv2.Warnings, error) {
	var arg1Copy []ccv2.Resource
	if arg1 != nil {
		arg1Copy = make([]ccv2.Resource, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.updateResourceMatchMutex.Lock()
	ret, specificReturn := fake.updateResourceMatchReturnsOnCall[len(fake.updateResourceMatchArgsForCall)]
	fake.updateResourceMatchArgsForCall = append(fake.updateResourceMatchArgsForCall, struct {
		arg1 []ccv2.Resource
	}{arg1Copy})
	fake.recordInvocation("UpdateResourceMatch", []interface{}{arg1Copy})
	fake.updateResourceMatchMutex.Unlock()
	if fake.UpdateResourceMatchStub != nil {
		return fake.UpdateResourceMatchStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateResourceMatchReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateResourceMatchCallCount() int {
	fake.updateResourceMatchMutex.RLock()
	defer fake.updateResourceMatchMutex.RUnlock()
	return len(fake.updateResourceMatchArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateResourceMatchCalls(stub func([]ccv2.Resource) ([]ccv2.Resource, ccv2.Warnings, error)) {
	fake.updateResourceMatchMutex.Lock()
	defer fake.updateResourceMatchMutex.Unlock()
	fake.UpdateResourceMatchStub = stub
}

func (fake *FakeCloudControllerClient) UpdateResourceMatchArgsForCall(i int) []ccv2.Resource {
	fake.updateResourceMatchMutex.RLock()
	defer fake.updateResourceMatchMutex.RUnlock()
	argsForCall := fake.updateResourceMatchArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateResourceMatchReturns(result1 []ccv2.Resource, result2 ccv2.Warnings, result3 error) {
	fake.updateResourceMatchMutex.Lock()
	defer fake.updateResourceMatchMutex.Unlock()
	fake.UpdateResourceMatchStub = nil
	fake.updateResourceMatchReturns = struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateResourceMatchReturnsOnCall(i int, result1 []ccv2.Resource, result2 ccv2.Warnings, result3 error) {
	fake.updateResourceMatchMutex.Lock()
	defer fake.updateResourceMatchMutex.Unlock()
	fake.UpdateResourceMatchStub = nil
	if fake.updateResourceMatchReturnsOnCall == nil {
		fake.updateResourceMatchReturnsOnCall = make(map[int]struct {
			result1 []ccv2.Resource
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.updateResourceMatchReturnsOnCall[i] = struct {
		result1 []ccv2.Resource
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateRouteApplication(arg1 string, arg2 string) (ccv2.Route, ccv2.Warnings, error) {
	fake.updateRouteApplicationMutex.Lock()
	ret, specificReturn := fake.updateRouteApplicationReturnsOnCall[len(fake.updateRouteApplicationArgsForCall)]
	fake.updateRouteApplicationArgsForCall = append(fake.updateRouteApplicationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateRouteApplication", []interface{}{arg1, arg2})
	fake.updateRouteApplicationMutex.Unlock()
	if fake.UpdateRouteApplicationStub != nil {
		return fake.UpdateRouteApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateRouteApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateRouteApplicationCallCount() int {
	fake.updateRouteApplicationMutex.RLock()
	defer fake.updateRouteApplicationMutex.RUnlock()
	return len(fake.updateRouteApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateRouteApplicationCalls(stub func(string, string) (ccv2.Route, ccv2.Warnings, error)) {
	fake.updateRouteApplicationMutex.Lock()
	defer fake.updateRouteApplicationMutex.Unlock()
	fake.UpdateRouteApplicationStub = stub
}

func (fake *FakeCloudControllerClient) UpdateRouteApplicationArgsForCall(i int) (string, string) {
	fake.updateRouteApplicationMutex.RLock()
	defer fake.updateRouteApplicationMutex.RUnlock()
	argsForCall := fake.updateRouteApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateRouteApplicationReturns(result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.updateRouteApplicationMutex.Lock()
	defer fake.updateRouteApplicationMutex.Unlock()
	fake.UpdateRouteApplicationStub = nil
	fake.updateRouteApplicationReturns = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateRouteApplicationReturnsOnCall(i int, result1 ccv2.Route, result2 ccv2.Warnings, result3 error) {
	fake.updateRouteApplicationMutex.Lock()
	defer fake.updateRouteApplicationMutex.Unlock()
	fake.UpdateRouteApplicationStub = nil
	if fake.updateRouteApplicationReturnsOnCall == nil {
		fake.updateRouteApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv2.Route
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.updateRouteApplicationReturnsOnCall[i] = struct {
		result1 ccv2.Route
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupSpace(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateSecurityGroupSpaceMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupSpaceReturnsOnCall[len(fake.updateSecurityGroupSpaceArgsForCall)]
	fake.updateSecurityGroupSpaceArgsForCall = append(fake.updateSecurityGroupSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSecurityGroupSpace", []interface{}{arg1, arg2})
	fake.updateSecurityGroupSpaceMutex.Unlock()
	if fake.UpdateSecurityGroupSpaceStub != nil {
		return fake.UpdateSecurityGroupSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSecurityGroupSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupSpaceCallCount() int {
	fake.updateSecurityGroupSpaceMutex.RLock()
	defer fake.updateSecurityGroupSpaceMutex.RUnlock()
	return len(fake.updateSecurityGroupSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupSpaceCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateSecurityGroupSpaceMutex.Lock()
	defer fake.updateSecurityGroupSpaceMutex.Unlock()
	fake.UpdateSecurityGroupSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupSpaceArgsForCall(i int) (string, string) {
	fake.updateSecurityGroupSpaceMutex.RLock()
	defer fake.updateSecurityGroupSpaceMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupSpaceReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateSecurityGroupSpaceMutex.Lock()
	defer fake.updateSecurityGroupSpaceMutex.Unlock()
	fake.UpdateSecurityGroupSpaceStub = nil
	fake.updateSecurityGroupSpaceReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupSpaceReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateSecurityGroupSpaceMutex.Lock()
	defer fake.updateSecurityGroupSpaceMutex.Unlock()
	fake.UpdateSecurityGroupSpaceStub = nil
	if fake.updateSecurityGroupSpaceReturnsOnCall == nil {
		fake.updateSecurityGroupSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateSecurityGroupSpaceReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpace(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupStagingSpaceReturnsOnCall[len(fake.updateSecurityGroupStagingSpaceArgsForCall)]
	fake.updateSecurityGroupStagingSpaceArgsForCall = append(fake.updateSecurityGroupStagingSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSecurityGroupStagingSpace", []interface{}{arg1, arg2})
	fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	if fake.UpdateSecurityGroupStagingSpaceStub != nil {
		return fake.UpdateSecurityGroupStagingSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSecurityGroupStagingSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceCallCount() int {
	fake.updateSecurityGroupStagingSpaceMutex.RLock()
	defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock()
	return len(fake.updateSecurityGroupStagingSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	defer fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	fake.UpdateSecurityGroupStagingSpaceStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceArgsForCall(i int) (string, string) {
	fake.updateSecurityGroupStagingSpaceMutex.RLock()
	defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupStagingSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	defer fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	fake.UpdateSecurityGroupStagingSpaceStub = nil
	fake.updateSecurityGroupStagingSpaceReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSecurityGroupStagingSpaceReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateSecurityGroupStagingSpaceMutex.Lock()
	defer fake.updateSecurityGroupStagingSpaceMutex.Unlock()
	fake.UpdateSecurityGroupStagingSpaceStub = nil
	if fake.updateSecurityGroupStagingSpaceReturnsOnCall == nil {
		fake.updateSecurityGroupStagingSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateSecurityGroupStagingSpaceReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateServicePlan(arg1 string, arg2 bool) (ccv2.Warnings, error) {
	fake.updateServicePlanMutex.Lock()
	ret, specificReturn := fake.updateServicePlanReturnsOnCall[len(fake.updateServicePlanArgsForCall)]
	fake.updateServicePlanArgsForCall = append(fake.updateServicePlanArgsForCall, struct {
		arg1 string
		arg2 bool
	}{arg1, arg2})
	fake.recordInvocation("UpdateServicePlan", []interface{}{arg1, arg2})
	fake.updateServicePlanMutex.Unlock()
	if fake.UpdateServicePlanStub != nil {
		return fake.UpdateServicePlanStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateServicePlanReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateServicePlanCallCount() int {
	fake.updateServicePlanMutex.RLock()
	defer fake.updateServicePlanMutex.RUnlock()
	return len(fake.updateServicePlanArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateServicePlanCalls(stub func(string, bool) (ccv2.Warnings, error)) {
	fake.updateServicePlanMutex.Lock()
	defer fake.updateServicePlanMutex.Unlock()
	fake.UpdateServicePlanStub = stub
}

func (fake *FakeCloudControllerClient) UpdateServicePlanArgsForCall(i int) (string, bool) {
	fake.updateServicePlanMutex.RLock()
	defer fake.updateServicePlanMutex.RUnlock()
	argsForCall := fake.updateServicePlanArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateServicePlanReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateServicePlanMutex.Lock()
	defer fake.updateServicePlanMutex.Unlock()
	fake.UpdateServicePlanStub = nil
	fake.updateServicePlanReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateServicePlanReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateServicePlanMutex.Lock()
	defer fake.updateServicePlanMutex.Unlock()
	fake.UpdateServicePlanStub = nil
	if fake.updateServicePlanReturnsOnCall == nil {
		fake.updateServicePlanReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateServicePlanReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloper(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateSpaceDeveloperMutex.Lock()
	ret, specificReturn := fake.updateSpaceDeveloperReturnsOnCall[len(fake.updateSpaceDeveloperArgsForCall)]
	fake.updateSpaceDeveloperArgsForCall = append(fake.updateSpaceDeveloperArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSpaceDeveloper", []interface{}{arg1, arg2})
	fake.updateSpaceDeveloperMutex.Unlock()
	if fake.UpdateSpaceDeveloperStub != nil {
		return fake.UpdateSpaceDeveloperStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceDeveloperReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperCallCount() int {
	fake.updateSpaceDeveloperMutex.RLock()
	defer fake.updateSpaceDeveloperMutex.RUnlock()
	return len(fake.updateSpaceDeveloperArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateSpaceDeveloperMutex.Lock()
	defer fake.updateSpaceDeveloperMutex.Unlock()
	fake.UpdateSpaceDeveloperStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperArgsForCall(i int) (string, string) {
	fake.updateSpaceDeveloperMutex.RLock()
	defer fake.updateSpaceDeveloperMutex.RUnlock()
	argsForCall := fake.updateSpaceDeveloperArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceDeveloperMutex.Lock()
	defer fake.updateSpaceDeveloperMutex.Unlock()
	fake.UpdateSpaceDeveloperStub = nil
	fake.updateSpaceDeveloperReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceDeveloperMutex.Lock()
	defer fake.updateSpaceDeveloperMutex.Unlock()
	fake.UpdateSpaceDeveloperStub = nil
	if fake.updateSpaceDeveloperReturnsOnCall == nil {
		fake.updateSpaceDeveloperReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateSpaceDeveloperReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperByUsername(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateSpaceDeveloperByUsernameMutex.Lock()
	ret, specificReturn := fake.updateSpaceDeveloperByUsernameReturnsOnCall[len(fake.updateSpaceDeveloperByUsernameArgsForCall)]
	fake.updateSpaceDeveloperByUsernameArgsForCall = append(fake.updateSpaceDeveloperByUsernameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSpaceDeveloperByUsername", []interface{}{arg1, arg2})
	fake.updateSpaceDeveloperByUsernameMutex.Unlock()
	if fake.UpdateSpaceDeveloperByUsernameStub != nil {
		return fake.UpdateSpaceDeveloperByUsernameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceDeveloperByUsernameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperByUsernameCallCount() int {
	fake.updateSpaceDeveloperByUsernameMutex.RLock()
	defer fake.updateSpaceDeveloperByUsernameMutex.RUnlock()
	return len(fake.updateSpaceDeveloperByUsernameArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperByUsernameCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateSpaceDeveloperByUsernameMutex.Lock()
	defer fake.updateSpaceDeveloperByUsernameMutex.Unlock()
	fake.UpdateSpaceDeveloperByUsernameStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperByUsernameArgsForCall(i int) (string, string) {
	fake.updateSpaceDeveloperByUsernameMutex.RLock()
	defer fake.updateSpaceDeveloperByUsernameMutex.RUnlock()
	argsForCall := fake.updateSpaceDeveloperByUsernameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperByUsernameReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceDeveloperByUsernameMutex.Lock()
	defer fake.updateSpaceDeveloperByUsernameMutex.Unlock()
	fake.UpdateSpaceDeveloperByUsernameStub = nil
	fake.updateSpaceDeveloperByUsernameReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceDeveloperByUsernameReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceDeveloperByUsernameMutex.Lock()
	defer fake.updateSpaceDeveloperByUsernameMutex.Unlock()
	fake.UpdateSpaceDeveloperByUsernameStub = nil
	if fake.updateSpaceDeveloperByUsernameReturnsOnCall == nil {
		fake.updateSpaceDeveloperByUsernameReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateSpaceDeveloperByUsernameReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceManager(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateSpaceManagerMutex.Lock()
	ret, specificReturn := fake.updateSpaceManagerReturnsOnCall[len(fake.updateSpaceManagerArgsForCall)]
	fake.updateSpaceManagerArgsForCall = append(fake.updateSpaceManagerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSpaceManager", []interface{}{arg1, arg2})
	fake.updateSpaceManagerMutex.Unlock()
	if fake.UpdateSpaceManagerStub != nil {
		return fake.UpdateSpaceManagerStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceManagerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerCallCount() int {
	fake.updateSpaceManagerMutex.RLock()
	defer fake.updateSpaceManagerMutex.RUnlock()
	return len(fake.updateSpaceManagerArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateSpaceManagerMutex.Lock()
	defer fake.updateSpaceManagerMutex.Unlock()
	fake.UpdateSpaceManagerStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerArgsForCall(i int) (string, string) {
	fake.updateSpaceManagerMutex.RLock()
	defer fake.updateSpaceManagerMutex.RUnlock()
	argsForCall := fake.updateSpaceManagerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceManagerMutex.Lock()
	defer fake.updateSpaceManagerMutex.Unlock()
	fake.UpdateSpaceManagerStub = nil
	fake.updateSpaceManagerReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceManagerMutex.Lock()
	defer fake.updateSpaceManagerMutex.Unlock()
	fake.UpdateSpaceManagerStub = nil
	if fake.updateSpaceManagerReturnsOnCall == nil {
		fake.updateSpaceManagerReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateSpaceManagerReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerByUsername(arg1 string, arg2 string) (ccv2.Warnings, error) {
	fake.updateSpaceManagerByUsernameMutex.Lock()
	ret, specificReturn := fake.updateSpaceManagerByUsernameReturnsOnCall[len(fake.updateSpaceManagerByUsernameArgsForCall)]
	fake.updateSpaceManagerByUsernameArgsForCall = append(fake.updateSpaceManagerByUsernameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSpaceManagerByUsername", []interface{}{arg1, arg2})
	fake.updateSpaceManagerByUsernameMutex.Unlock()
	if fake.UpdateSpaceManagerByUsernameStub != nil {
		return fake.UpdateSpaceManagerByUsernameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceManagerByUsernameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerByUsernameCallCount() int {
	fake.updateSpaceManagerByUsernameMutex.RLock()
	defer fake.updateSpaceManagerByUsernameMutex.RUnlock()
	return len(fake.updateSpaceManagerByUsernameArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerByUsernameCalls(stub func(string, string) (ccv2.Warnings, error)) {
	fake.updateSpaceManagerByUsernameMutex.Lock()
	defer fake.updateSpaceManagerByUsernameMutex.Unlock()
	fake.UpdateSpaceManagerByUsernameStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerByUsernameArgsForCall(i int) (string, string) {
	fake.updateSpaceManagerByUsernameMutex.RLock()
	defer fake.updateSpaceManagerByUsernameMutex.RUnlock()
	argsForCall := fake.updateSpaceManagerByUsernameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerByUsernameReturns(result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceManagerByUsernameMutex.Lock()
	defer fake.updateSpaceManagerByUsernameMutex.Unlock()
	fake.UpdateSpaceManagerByUsernameStub = nil
	fake.updateSpaceManagerByUsernameReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateSpaceManagerByUsernameReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.updateSpaceManagerByUsernameMutex.Lock()
	defer fake.updateSpaceManagerByUsernameMutex.Unlock()
	fake.UpdateSpaceManagerByUsernameStub = nil
	if fake.updateSpaceManagerByUsernameReturnsOnCall == nil {
		fake.updateSpaceManagerByUsernameReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.updateSpaceManagerByUsernameReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UploadApplicationPackage(arg1 string, arg2 []ccv2.Resource, arg3 ccv2.Reader, arg4 int64) (ccv2.Job, ccv2.Warnings, error) {
	var arg2Copy []ccv2.Resource
	if arg2 != nil {
		arg2Copy = make([]ccv2.Resource, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.uploadApplicationPackageMutex.Lock()
	ret, specificReturn := fake.uploadApplicationPackageReturnsOnCall[len(fake.uploadApplicationPackageArgsForCall)]
	fake.uploadApplicationPackageArgsForCall = append(fake.uploadApplicationPackageArgsForCall, struct {
		arg1 string
		arg2 []ccv2.Resource
		arg3 ccv2.Reader
		arg4 int64
	}{arg1, arg2Copy, arg3, arg4})
	fake.recordInvocation("UploadApplicationPackage", []interface{}{arg1, arg2Copy, arg3, arg4})
	fake.uploadApplicationPackageMutex.Unlock()
	if fake.UploadApplicationPackageStub != nil {
		return fake.UploadApplicationPackageStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadApplicationPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageCallCount() int {
	fake.uploadApplicationPackageMutex.RLock()
	defer fake.uploadApplicationPackageMutex.RUnlock()
	return len(fake.uploadApplicationPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageCalls(stub func(string, []ccv2.Resource, ccv2.Reader, int64) (ccv2.Job, ccv2.Warnings, error)) {
	fake.uploadApplicationPackageMutex.Lock()
	defer fake.uploadApplicationPackageMutex.Unlock()
	fake.UploadApplicationPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageArgsForCall(i int) (string, []ccv2.Resource, ccv2.Reader, int64) {
	fake.uploadApplicationPackageMutex.RLock()
	defer fake.uploadApplicationPackageMutex.RUnlock()
	argsForCall := fake.uploadApplicationPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.uploadApplicationPackageMutex.Lock()
	defer fake.uploadApplicationPackageMutex.Unlock()
	fake.UploadApplicationPackageStub = nil
	fake.uploadApplicationPackageReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadApplicationPackageReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.uploadApplicationPackageMutex.Lock()
	defer fake.uploadApplicationPackageMutex.Unlock()
	fake.UploadApplicationPackageStub = nil
	if fake.uploadApplicationPackageReturnsOnCall == nil {
		fake.uploadApplicationPackageReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.uploadApplicationPackageReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBuildpack(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (ccv2.Warnings, error) {
	fake.uploadBuildpackMutex.Lock()
	ret, specificReturn := fake.uploadBuildpackReturnsOnCall[len(fake.uploadBuildpackArgsForCall)]
	fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UploadBuildpack", []interface{}{arg1, arg2, arg3, arg4})
	fake.uploadBuildpackMutex.Unlock()
	if fake.UploadBuildpackStub != nil {
		return fake.UploadBuildpackStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.uploadBuildpackReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UploadBuildpackCallCount() int {
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	return len(fake.uploadBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadBuildpackCalls(stub func(string, string, io.Reader, int64) (ccv2.Warnings, error)) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) UploadBuildpackArgsForCall(i int) (string, string, io.Reader, int64) {
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	argsForCall := fake.uploadBuildpackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) UploadBuildpackReturns(result1 ccv2.Warnings, result2 error) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = nil
	fake.uploadBuildpackReturns = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UploadBuildpackReturnsOnCall(i int, result1 ccv2.Warnings, result2 error) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = nil
	if fake.uploadBuildpackReturnsOnCall == nil {
		fake.uploadBuildpackReturnsOnCall = make(map[int]struct {
			result1 ccv2.Warnings
			result2 error
		})
	}
	fake.uploadBuildpackReturnsOnCall[i] = struct {
		result1 ccv2.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UploadDroplet(arg1 string, arg2 io.Reader, arg3 int64) (ccv2.Job, ccv2.Warnings, error) {
	fake.uploadDropletMutex.Lock()
	ret, specificReturn := fake.uploadDropletReturnsOnCall[len(fake.uploadDropletArgsForCall)]
	fake.uploadDropletArgsForCall = append(fake.uploadDropletArgsForCall, struct {
		arg1 string
		arg2 io.Reader
		arg3 int64
	}{arg1, arg2, arg3})
	fake.recordInvocation("UploadDroplet", []interface{}{arg1, arg2, arg3})
	fake.uploadDropletMutex.Unlock()
	if fake.UploadDropletStub != nil {
		return fake.UploadDropletStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadDropletReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadDropletCallCount() int {
	fake.uploadDropletMutex.RLock()
	defer fake.uploadDropletMutex.RUnlock()
	return len(fake.uploadDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadDropletCalls(stub func(string, io.Reader, int64) (ccv2.Job, ccv2.Warnings, error)) {
	fake.uploadDropletMutex.Lock()
	defer fake.uploadDropletMutex.Unlock()
	fake.UploadDropletStub = stub
}

func (fake *FakeCloudControllerClient) UploadDropletArgsForCall(i int) (string, io.Reader, int64) {
	fake.uploadDropletMutex.RLock()
	defer fake.uploadDropletMutex.RUnlock()
	argsForCall := fake.uploadDropletArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) UploadDropletReturns(result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.uploadDropletMutex.Lock()
	defer fake.uploadDropletMutex.Unlock()
	fake.UploadDropletStub = nil
	fake.uploadDropletReturns = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadDropletReturnsOnCall(i int, result1 ccv2.Job, result2 ccv2.Warnings, result3 error) {
	fake.uploadDropletMutex.Lock()
	defer fake.uploadDropletMutex.Unlock()
	fake.UploadDropletStub = nil
	if fake.uploadDropletReturnsOnCall == nil {
		fake.uploadDropletReturnsOnCall = make(map[int]struct {
			result1 ccv2.Job
			result2 ccv2.Warnings
			result3 error
		})
	}
	fake.uploadDropletReturnsOnCall[i] = struct {
		result1 ccv2.Job
		result2 ccv2.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.aPIMutex.RLock()
	defer fake.aPIMutex.RUnlock()
	fake.aPIVersionMutex.RLock()
	defer fake.aPIVersionMutex.RUnlock()
	fake.authorizationEndpointMutex.RLock()
	defer fake.authorizationEndpointMutex.RUnlock()
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	fake.createServiceBindingMutex.RLock()
	defer fake.createServiceBindingMutex.RUnlock()
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	fake.createServiceKeyMutex.RLock()
	defer fake.createServiceKeyMutex.RUnlock()
	fake.createServicePlanVisibilityMutex.RLock()
	defer fake.createServicePlanVisibilityMutex.RUnlock()
	fake.createSharedDomainMutex.RLock()
	defer fake.createSharedDomainMutex.RUnlock()
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	fake.deleteOrganizationJobMutex.RLock()
	defer fake.deleteOrganizationJobMutex.RUnlock()
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	fake.deleteRouteApplicationMutex.RLock()
	defer fake.deleteRouteApplicationMutex.RUnlock()
	fake.deleteSecurityGroupSpaceMutex.RLock()
	defer fake.deleteSecurityGroupSpaceMutex.RUnlock()
	fake.deleteSecurityGroupStagingSpaceMutex.RLock()
	defer fake.deleteSecurityGroupStagingSpaceMutex.RUnlock()
	fake.deleteServiceBindingMutex.RLock()
	defer fake.deleteServiceBindingMutex.RUnlock()
	fake.deleteServicePlanVisibilityMutex.RLock()
	defer fake.deleteServicePlanVisibilityMutex.RUnlock()
	fake.deleteSpaceJobMutex.RLock()
	defer fake.deleteSpaceJobMutex.RUnlock()
	fake.dopplerEndpointMutex.RLock()
	defer fake.dopplerEndpointMutex.RUnlock()
	fake.getApplicationMutex.RLock()
	defer fake.getApplicationMutex.RUnlock()
	fake.getApplicationApplicationInstanceStatusesMutex.RLock()
	defer fake.getApplicationApplicationInstanceStatusesMutex.RUnlock()
	fake.getApplicationApplicationInstancesMutex.RLock()
	defer fake.getApplicationApplicationInstancesMutex.RUnlock()
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	fake.getConfigFeatureFlagsMutex.RLock()
	defer fake.getConfigFeatureFlagsMutex.RUnlock()
	fake.getJobMutex.RLock()
	defer fake.getJobMutex.RUnlock()
	fake.getOrganizationMutex.RLock()
	defer fake.getOrganizationMutex.RUnlock()
	fake.getOrganizationPrivateDomainsMutex.RLock()
	defer fake.getOrganizationPrivateDomainsMutex.RUnlock()
	fake.getOrganizationQuotaMutex.RLock()
	defer fake.getOrganizationQuotaMutex.RUnlock()
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getPrivateDomainMutex.RLock()
	defer fake.getPrivateDomainMutex.RUnlock()
	fake.getRouteApplicationsMutex.RLock()
	defer fake.getRouteApplicationsMutex.RUnlock()
	fake.getRoutesMutex.RLock()
	defer fake.getRoutesMutex.RUnlock()
	fake.getSecurityGroupSpacesMutex.RLock()
	defer fake.getSecurityGroupSpacesMutex.RUnlock()
	fake.getSecurityGroupStagingSpacesMutex.RLock()
	defer fake.getSecurityGroupStagingSpacesMutex.RUnlock()
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	fake.getServiceMutex.RLock()
	defer fake.getServiceMutex.RUnlock()
	fake.getServiceBindingsMutex.RLock()
	defer fake.getServiceBindingsMutex.RUnlock()
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	fake.getServiceInstanceMutex.RLock()
	defer fake.getServiceInstanceMutex.RUnlock()
	fake.getServiceInstanceServiceBindingsMutex.RLock()
	defer fake.getServiceInstanceServiceBindingsMutex.RUnlock()
	fake.getServiceInstanceSharedFromMutex.RLock()
	defer fake.getServiceInstanceSharedFromMutex.RUnlock()
	fake.getServiceInstanceSharedTosMutex.RLock()
	defer fake.getServiceInstanceSharedTosMutex.RUnlock()
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	fake.getServicePlanMutex.RLock()
	defer fake.getServicePlanMutex.RUnlock()
	fake.getServicePlanVisibilitiesMutex.RLock()
	defer fake.getServicePlanVisibilitiesMutex.RUnlock()
	fake.getServicePlansMutex.RLock()
	defer fake.getServicePlansMutex.RUnlock()
	fake.getServicesMutex.RLock()
	defer fake.getServicesMutex.RUnlock()
	fake.getSharedDomainMutex.RLock()
	defer fake.getSharedDomainMutex.RUnlock()
	fake.getSharedDomainsMutex.RLock()
	defer fake.getSharedDomainsMutex.RUnlock()
	fake.getSpaceQuotaDefinitionMutex.RLock()
	defer fake.getSpaceQuotaDefinitionMutex.RUnlock()
	fake.getSpaceQuotasMutex.RLock()
	defer fake.getSpaceQuotasMutex.RUnlock()
	fake.getSpaceRoutesMutex.RLock()
	defer fake.getSpaceRoutesMutex.RUnlock()
	fake.getSpaceSecurityGroupsMutex.RLock()
	defer fake.getSpaceSecurityGroupsMutex.RUnlock()
	fake.getSpaceServiceInstancesMutex.RLock()
	defer fake.getSpaceServiceInstancesMutex.RUnlock()
	fake.getSpaceServicesMutex.RLock()
	defer fake.getSpaceServicesMutex.RUnlock()
	fake.getSpaceStagingSecurityGroupsMutex.RLock()
	defer fake.getSpaceStagingSecurityGroupsMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.getStackMutex.RLock()
	defer fake.getStackMutex.RUnlock()
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	fake.getUserProvidedServiceInstanceServiceBindingsMutex.RLock()
	defer fake.getUserProvidedServiceInstanceServiceBindingsMutex.RUnlock()
	fake.minCLIVersionMutex.RLock()
	defer fake.minCLIVersionMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.restageApplicationMutex.RLock()
	defer fake.restageApplicationMutex.RUnlock()
	fake.routingEndpointMutex.RLock()
	defer fake.routingEndpointMutex.RUnlock()
	fake.setSpaceQuotaMutex.RLock()
	defer fake.setSpaceQuotaMutex.RUnlock()
	fake.targetCFMutex.RLock()
	defer fake.targetCFMutex.RUnlock()
	fake.tokenEndpointMutex.RLock()
	defer fake.tokenEndpointMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	fake.updateOrganizationManagerMutex.RLock()
	defer fake.updateOrganizationManagerMutex.RUnlock()
	fake.updateOrganizationManagerByUsernameMutex.RLock()
	defer fake.updateOrganizationManagerByUsernameMutex.RUnlock()
	fake.updateOrganizationUserMutex.RLock()
	defer fake.updateOrganizationUserMutex.RUnlock()
	fake.updateOrganizationUserByUsernameMutex.RLock()
	defer fake.updateOrganizationUserByUsernameMutex.RUnlock()
	fake.updateResourceMatchMutex.RLock()
	defer fake.updateResourceMatchMutex.RUnlock()
	fake.updateRouteApplicationMutex.RLock()
	defer fake.updateRouteApplicationMutex.RUnlock()
	fake.updateSecurityGroupSpaceMutex.RLock()
	defer fake.updateSecurityGroupSpaceMutex.RUnlock()
	fake.updateSecurityGroupStagingSpaceMutex.RLock()
	defer fake.updateSecurityGroupStagingSpaceMutex.RUnlock()
	fake.updateServicePlanMutex.RLock()
	defer fake.updateServicePlanMutex.RUnlock()
	fake.updateSpaceDeveloperMutex.RLock()
	defer fake.updateSpaceDeveloperMutex.RUnlock()
	fake.updateSpaceDeveloperByUsernameMutex.RLock()
	defer fake.updateSpaceDeveloperByUsernameMutex.RUnlock()
	fake.updateSpaceManagerMutex.RLock()
	defer fake.updateSpaceManagerMutex.RUnlock()
	fake.updateSpaceManagerByUsernameMutex.RLock()
	defer fake.updateSpaceManagerByUsernameMutex.RUnlock()
	fake.uploadApplicationPackageMutex.RLock()
	defer fake.uploadApplicationPackageMutex.RUnlock()
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	fake.uploadDropletMutex.RLock()
	defer fake.uploadDropletMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeCloudControllerClient) 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 _ v2action.CloudControllerClient = new(FakeCloudControllerClient)