github.com/cloudfoundry-community/cloudfoundry-cli@v6.44.1-0.20240130060226-cda5ed8e89a5+incompatible/actor/v7action/v7actionfakes/fake_cloud_controller_client.go

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

import (
	"code.cloudfoundry.org/cli/resources"
	"io"
	"sync"

	"code.cloudfoundry.org/cli/actor/v7action"
	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
)

type FakeCloudControllerClient struct {
	AppSSHEndpointStub        func() string
	appSSHEndpointMutex       sync.RWMutex
	appSSHEndpointArgsForCall []struct {
	}
	appSSHEndpointReturns struct {
		result1 string
	}
	appSSHEndpointReturnsOnCall map[int]struct {
		result1 string
	}
	AppSSHHostKeyFingerprintStub        func() string
	appSSHHostKeyFingerprintMutex       sync.RWMutex
	appSSHHostKeyFingerprintArgsForCall []struct {
	}
	appSSHHostKeyFingerprintReturns struct {
		result1 string
	}
	appSSHHostKeyFingerprintReturnsOnCall map[int]struct {
		result1 string
	}
	CloudControllerAPIVersionStub        func() string
	cloudControllerAPIVersionMutex       sync.RWMutex
	cloudControllerAPIVersionArgsForCall []struct {
	}
	cloudControllerAPIVersionReturns struct {
		result1 string
	}
	cloudControllerAPIVersionReturnsOnCall map[int]struct {
		result1 string
	}
	CreateApplicationStub        func(resources.Application) (resources.Application, ccv3.Warnings, error)
	createApplicationMutex       sync.RWMutex
	createApplicationArgsForCall []struct {
		arg1 resources.Application
	}
	createApplicationReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationProcessScaleStub        func(string, resources.Process) (resources.Process, ccv3.Warnings, error)
	createApplicationProcessScaleMutex       sync.RWMutex
	createApplicationProcessScaleArgsForCall []struct {
		arg1 string
		arg2 resources.Process
	}
	createApplicationProcessScaleReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationProcessScaleReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	CreateApplicationTaskStub        func(string, resources.Task) (resources.Task, ccv3.Warnings, error)
	createApplicationTaskMutex       sync.RWMutex
	createApplicationTaskArgsForCall []struct {
		arg1 string
		arg2 resources.Task
	}
	createApplicationTaskReturns struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	createApplicationTaskReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	CreateBuildStub        func(resources.Build) (resources.Build, ccv3.Warnings, error)
	createBuildMutex       sync.RWMutex
	createBuildArgsForCall []struct {
		arg1 resources.Build
	}
	createBuildReturns struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	createBuildReturnsOnCall map[int]struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	CreateBuildpackStub        func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)
	createBuildpackMutex       sync.RWMutex
	createBuildpackArgsForCall []struct {
		arg1 resources.Buildpack
	}
	createBuildpackReturns struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	createBuildpackReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	CreateDomainStub        func(resources.Domain) (resources.Domain, ccv3.Warnings, error)
	createDomainMutex       sync.RWMutex
	createDomainArgsForCall []struct {
		arg1 resources.Domain
	}
	createDomainReturns struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	createDomainReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	CreateIsolationSegmentStub        func(resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error)
	createIsolationSegmentMutex       sync.RWMutex
	createIsolationSegmentArgsForCall []struct {
		arg1 resources.IsolationSegment
	}
	createIsolationSegmentReturns struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	createIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	CreatePackageStub        func(resources.Package) (resources.Package, ccv3.Warnings, error)
	createPackageMutex       sync.RWMutex
	createPackageArgsForCall []struct {
		arg1 resources.Package
	}
	createPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	createPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	DeleteApplicationStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteApplicationMutex       sync.RWMutex
	deleteApplicationArgsForCall []struct {
		arg1 string
	}
	deleteApplicationReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteApplicationReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteApplicationProcessInstanceStub        func(string, string, int) (ccv3.Warnings, error)
	deleteApplicationProcessInstanceMutex       sync.RWMutex
	deleteApplicationProcessInstanceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 int
	}
	deleteApplicationProcessInstanceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteApplicationProcessInstanceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteBuildpackStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteBuildpackMutex       sync.RWMutex
	deleteBuildpackArgsForCall []struct {
		arg1 string
	}
	deleteBuildpackReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteBuildpackReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteDomainStub        func(string) (ccv3.JobURL, ccv3.Warnings, error)
	deleteDomainMutex       sync.RWMutex
	deleteDomainArgsForCall []struct {
		arg1 string
	}
	deleteDomainReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	deleteDomainReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	DeleteIsolationSegmentStub        func(string) (ccv3.Warnings, error)
	deleteIsolationSegmentMutex       sync.RWMutex
	deleteIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	deleteIsolationSegmentReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteIsolationSegmentReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteIsolationSegmentOrganizationStub        func(string, string) (ccv3.Warnings, error)
	deleteIsolationSegmentOrganizationMutex       sync.RWMutex
	deleteIsolationSegmentOrganizationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteIsolationSegmentOrganizationReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteIsolationSegmentOrganizationReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	DeleteServiceInstanceRelationshipsSharedSpaceStub        func(string, string) (ccv3.Warnings, error)
	deleteServiceInstanceRelationshipsSharedSpaceMutex       sync.RWMutex
	deleteServiceInstanceRelationshipsSharedSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteServiceInstanceRelationshipsSharedSpaceReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	EntitleIsolationSegmentToOrganizationsStub        func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)
	entitleIsolationSegmentToOrganizationsMutex       sync.RWMutex
	entitleIsolationSegmentToOrganizationsArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	entitleIsolationSegmentToOrganizationsReturns struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	entitleIsolationSegmentToOrganizationsReturnsOnCall map[int]struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationDropletCurrentStub        func(string) (resources.Droplet, ccv3.Warnings, error)
	getApplicationDropletCurrentMutex       sync.RWMutex
	getApplicationDropletCurrentArgsForCall []struct {
		arg1 string
	}
	getApplicationDropletCurrentReturns struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationDropletCurrentReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationEnvironmentStub        func(string) (ccv3.Environment, ccv3.Warnings, error)
	getApplicationEnvironmentMutex       sync.RWMutex
	getApplicationEnvironmentArgsForCall []struct {
		arg1 string
	}
	getApplicationEnvironmentReturns struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationEnvironmentReturnsOnCall map[int]struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationManifestStub        func(string) ([]byte, ccv3.Warnings, error)
	getApplicationManifestMutex       sync.RWMutex
	getApplicationManifestArgsForCall []struct {
		arg1 string
	}
	getApplicationManifestReturns struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationManifestReturnsOnCall map[int]struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationProcessByTypeStub        func(string, string) (resources.Process, ccv3.Warnings, error)
	getApplicationProcessByTypeMutex       sync.RWMutex
	getApplicationProcessByTypeArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationProcessByTypeReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessByTypeReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationProcessesStub        func(string) ([]resources.Process, ccv3.Warnings, error)
	getApplicationProcessesMutex       sync.RWMutex
	getApplicationProcessesArgsForCall []struct {
		arg1 string
	}
	getApplicationProcessesReturns struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationProcessesReturnsOnCall map[int]struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationTasksStub        func(string, ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error)
	getApplicationTasksMutex       sync.RWMutex
	getApplicationTasksArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getApplicationTasksReturns struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationTasksReturnsOnCall map[int]struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	GetApplicationsStub        func(...ccv3.Query) ([]resources.Application, ccv3.Warnings, error)
	getApplicationsMutex       sync.RWMutex
	getApplicationsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getApplicationsReturns struct {
		result1 []resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	getApplicationsReturnsOnCall map[int]struct {
		result1 []resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	GetBuildStub        func(string) (resources.Build, ccv3.Warnings, error)
	getBuildMutex       sync.RWMutex
	getBuildArgsForCall []struct {
		arg1 string
	}
	getBuildReturns struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	getBuildReturnsOnCall map[int]struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}
	GetBuildpacksStub        func(...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error)
	getBuildpacksMutex       sync.RWMutex
	getBuildpacksArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getBuildpacksReturns struct {
		result1 []resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	getBuildpacksReturnsOnCall map[int]struct {
		result1 []resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	GetDomainsStub        func(...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)
	getDomainsMutex       sync.RWMutex
	getDomainsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getDomainsReturns struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	getDomainsReturnsOnCall map[int]struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	GetDropletStub        func(string) (resources.Droplet, ccv3.Warnings, error)
	getDropletMutex       sync.RWMutex
	getDropletArgsForCall []struct {
		arg1 string
	}
	getDropletReturns struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getDropletReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetDropletsStub        func(...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error)
	getDropletsMutex       sync.RWMutex
	getDropletsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getDropletsReturns struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	getDropletsReturnsOnCall map[int]struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}
	GetFeatureFlagStub        func(string) (resources.FeatureFlag, ccv3.Warnings, error)
	getFeatureFlagMutex       sync.RWMutex
	getFeatureFlagArgsForCall []struct {
		arg1 string
	}
	getFeatureFlagReturns struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	getFeatureFlagReturnsOnCall map[int]struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	GetFeatureFlagsStub        func() ([]resources.FeatureFlag, ccv3.Warnings, error)
	getFeatureFlagsMutex       sync.RWMutex
	getFeatureFlagsArgsForCall []struct {
	}
	getFeatureFlagsReturns struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	getFeatureFlagsReturnsOnCall map[int]struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentStub        func(string) (resources.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentMutex       sync.RWMutex
	getIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentReturns struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentOrganizationsStub        func(string) ([]resources.Organization, ccv3.Warnings, error)
	getIsolationSegmentOrganizationsMutex       sync.RWMutex
	getIsolationSegmentOrganizationsArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentOrganizationsReturns struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentOrganizationsReturnsOnCall map[int]struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetIsolationSegmentsStub        func(...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error)
	getIsolationSegmentsMutex       sync.RWMutex
	getIsolationSegmentsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getIsolationSegmentsReturns struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	getIsolationSegmentsReturnsOnCall map[int]struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationDefaultIsolationSegmentStub        func(string) (resources.Relationship, ccv3.Warnings, error)
	getOrganizationDefaultIsolationSegmentMutex       sync.RWMutex
	getOrganizationDefaultIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getOrganizationDefaultIsolationSegmentReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationDefaultIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationDomainsStub        func(string, ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)
	getOrganizationDomainsMutex       sync.RWMutex
	getOrganizationDomainsArgsForCall []struct {
		arg1 string
		arg2 []ccv3.Query
	}
	getOrganizationDomainsReturns struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationDomainsReturnsOnCall map[int]struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}
	GetOrganizationsStub        func(...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error)
	getOrganizationsMutex       sync.RWMutex
	getOrganizationsArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getOrganizationsReturns struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	getOrganizationsReturnsOnCall map[int]struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	GetPackageStub        func(string) (resources.Package, ccv3.Warnings, error)
	getPackageMutex       sync.RWMutex
	getPackageArgsForCall []struct {
		arg1 string
	}
	getPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	getPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	GetPackagesStub        func(...ccv3.Query) ([]resources.Package, ccv3.Warnings, error)
	getPackagesMutex       sync.RWMutex
	getPackagesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getPackagesReturns struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	getPackagesReturnsOnCall map[int]struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	GetProcessInstancesStub        func(string) ([]ccv3.ProcessInstance, ccv3.Warnings, error)
	getProcessInstancesMutex       sync.RWMutex
	getProcessInstancesArgsForCall []struct {
		arg1 string
	}
	getProcessInstancesReturns struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}
	getProcessInstancesReturnsOnCall map[int]struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}
	GetServiceInstancesStub        func(...ccv3.Query) ([]resources.ServiceInstance, ccv3.Warnings, error)
	getServiceInstancesMutex       sync.RWMutex
	getServiceInstancesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getServiceInstancesReturns struct {
		result1 []resources.ServiceInstance
		result2 ccv3.Warnings
		result3 error
	}
	getServiceInstancesReturnsOnCall map[int]struct {
		result1 []resources.ServiceInstance
		result2 ccv3.Warnings
		result3 error
	}
	GetSpaceIsolationSegmentStub        func(string) (resources.Relationship, ccv3.Warnings, error)
	getSpaceIsolationSegmentMutex       sync.RWMutex
	getSpaceIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	getSpaceIsolationSegmentReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	getSpaceIsolationSegmentReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	GetSpacesStub        func(...ccv3.Query) ([]resources.Space, ccv3.Warnings, error)
	getSpacesMutex       sync.RWMutex
	getSpacesArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getSpacesReturns struct {
		result1 []resources.Space
		result2 ccv3.Warnings
		result3 error
	}
	getSpacesReturnsOnCall map[int]struct {
		result1 []resources.Space
		result2 ccv3.Warnings
		result3 error
	}
	GetStacksStub        func(...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error)
	getStacksMutex       sync.RWMutex
	getStacksArgsForCall []struct {
		arg1 []ccv3.Query
	}
	getStacksReturns struct {
		result1 []resources.Stack
		result2 ccv3.Warnings
		result3 error
	}
	getStacksReturnsOnCall map[int]struct {
		result1 []resources.Stack
		result2 ccv3.Warnings
		result3 error
	}
	PollJobStub        func(ccv3.JobURL) (ccv3.Warnings, error)
	pollJobMutex       sync.RWMutex
	pollJobArgsForCall []struct {
		arg1 ccv3.JobURL
	}
	pollJobReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	pollJobReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	ResourceMatchStub        func([]ccv3.Resource) ([]ccv3.Resource, ccv3.Warnings, error)
	resourceMatchMutex       sync.RWMutex
	resourceMatchArgsForCall []struct {
		arg1 []ccv3.Resource
	}
	resourceMatchReturns struct {
		result1 []ccv3.Resource
		result2 ccv3.Warnings
		result3 error
	}
	resourceMatchReturnsOnCall map[int]struct {
		result1 []ccv3.Resource
		result2 ccv3.Warnings
		result3 error
	}
	SetApplicationDropletStub        func(string, string) (resources.Relationship, ccv3.Warnings, error)
	setApplicationDropletMutex       sync.RWMutex
	setApplicationDropletArgsForCall []struct {
		arg1 string
		arg2 string
	}
	setApplicationDropletReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	setApplicationDropletReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	SharePrivateDomainToOrgsStub        func(string, ccv3.SharedOrgs) (ccv3.Warnings, error)
	sharePrivateDomainToOrgsMutex       sync.RWMutex
	sharePrivateDomainToOrgsArgsForCall []struct {
		arg1 string
		arg2 ccv3.SharedOrgs
	}
	sharePrivateDomainToOrgsReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	sharePrivateDomainToOrgsReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	ShareServiceInstanceToSpacesStub        func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)
	shareServiceInstanceToSpacesMutex       sync.RWMutex
	shareServiceInstanceToSpacesArgsForCall []struct {
		arg1 string
		arg2 []string
	}
	shareServiceInstanceToSpacesReturns struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	shareServiceInstanceToSpacesReturnsOnCall map[int]struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}
	UnsharePrivateDomainFromOrgStub        func(string, string) (ccv3.Warnings, error)
	unsharePrivateDomainFromOrgMutex       sync.RWMutex
	unsharePrivateDomainFromOrgArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unsharePrivateDomainFromOrgReturns struct {
		result1 ccv3.Warnings
		result2 error
	}
	unsharePrivateDomainFromOrgReturnsOnCall map[int]struct {
		result1 ccv3.Warnings
		result2 error
	}
	UpdateApplicationStub        func(resources.Application) (resources.Application, ccv3.Warnings, error)
	updateApplicationMutex       sync.RWMutex
	updateApplicationArgsForCall []struct {
		arg1 resources.Application
	}
	updateApplicationReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationApplyManifestStub        func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error)
	updateApplicationApplyManifestMutex       sync.RWMutex
	updateApplicationApplyManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	updateApplicationApplyManifestReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationApplyManifestReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationEnvironmentVariablesStub        func(string, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error)
	updateApplicationEnvironmentVariablesMutex       sync.RWMutex
	updateApplicationEnvironmentVariablesArgsForCall []struct {
		arg1 string
		arg2 resources.EnvironmentVariables
	}
	updateApplicationEnvironmentVariablesReturns struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationEnvironmentVariablesReturnsOnCall map[int]struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationRestartStub        func(string) (resources.Application, ccv3.Warnings, error)
	updateApplicationRestartMutex       sync.RWMutex
	updateApplicationRestartArgsForCall []struct {
		arg1 string
	}
	updateApplicationRestartReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationRestartReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationStartStub        func(string) (resources.Application, ccv3.Warnings, error)
	updateApplicationStartMutex       sync.RWMutex
	updateApplicationStartArgsForCall []struct {
		arg1 string
	}
	updateApplicationStartReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationStartReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateApplicationStopStub        func(string) (resources.Application, ccv3.Warnings, error)
	updateApplicationStopMutex       sync.RWMutex
	updateApplicationStopArgsForCall []struct {
		arg1 string
	}
	updateApplicationStopReturns struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	updateApplicationStopReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}
	UpdateBuildpackStub        func(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)
	updateBuildpackMutex       sync.RWMutex
	updateBuildpackArgsForCall []struct {
		arg1 resources.Buildpack
	}
	updateBuildpackReturns struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	updateBuildpackReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 ccv3.Warnings
		result3 error
	}
	UpdateFeatureFlagStub        func(resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error)
	updateFeatureFlagMutex       sync.RWMutex
	updateFeatureFlagArgsForCall []struct {
		arg1 resources.FeatureFlag
	}
	updateFeatureFlagReturns struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	updateFeatureFlagReturnsOnCall map[int]struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}
	UpdateOrganizationStub        func(resources.Organization) (resources.Organization, ccv3.Warnings, error)
	updateOrganizationMutex       sync.RWMutex
	updateOrganizationArgsForCall []struct {
		arg1 resources.Organization
	}
	updateOrganizationReturns struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	updateOrganizationReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}
	UpdateOrganizationDefaultIsolationSegmentRelationshipStub        func(string, string) (resources.Relationship, ccv3.Warnings, error)
	updateOrganizationDefaultIsolationSegmentRelationshipMutex       sync.RWMutex
	updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateOrganizationDefaultIsolationSegmentRelationshipReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	UpdateProcessStub        func(resources.Process) (resources.Process, ccv3.Warnings, error)
	updateProcessMutex       sync.RWMutex
	updateProcessArgsForCall []struct {
		arg1 resources.Process
	}
	updateProcessReturns struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	updateProcessReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSpaceApplyManifestStub        func(string, []byte, ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error)
	updateSpaceApplyManifestMutex       sync.RWMutex
	updateSpaceApplyManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
		arg3 []ccv3.Query
	}
	updateSpaceApplyManifestReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	updateSpaceApplyManifestReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UpdateSpaceIsolationSegmentRelationshipStub        func(string, string) (resources.Relationship, ccv3.Warnings, error)
	updateSpaceIsolationSegmentRelationshipMutex       sync.RWMutex
	updateSpaceIsolationSegmentRelationshipArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSpaceIsolationSegmentRelationshipReturns struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	updateSpaceIsolationSegmentRelationshipReturnsOnCall map[int]struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}
	UpdateTaskCancelStub        func(string) (resources.Task, ccv3.Warnings, error)
	updateTaskCancelMutex       sync.RWMutex
	updateTaskCancelArgsForCall []struct {
		arg1 string
	}
	updateTaskCancelReturns struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	updateTaskCancelReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}
	UploadBitsPackageStub        func(resources.Package, []ccv3.Resource, io.Reader, int64) (resources.Package, ccv3.Warnings, error)
	uploadBitsPackageMutex       sync.RWMutex
	uploadBitsPackageArgsForCall []struct {
		arg1 resources.Package
		arg2 []ccv3.Resource
		arg3 io.Reader
		arg4 int64
	}
	uploadBitsPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	uploadBitsPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	UploadBuildpackStub        func(string, string, io.Reader, int64) (ccv3.JobURL, ccv3.Warnings, error)
	uploadBuildpackMutex       sync.RWMutex
	uploadBuildpackArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}
	uploadBuildpackReturns struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	uploadBuildpackReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}
	UploadPackageStub        func(resources.Package, string) (resources.Package, ccv3.Warnings, error)
	uploadPackageMutex       sync.RWMutex
	uploadPackageArgsForCall []struct {
		arg1 resources.Package
		arg2 string
	}
	uploadPackageReturns struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	uploadPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeCloudControllerClient) AppSSHEndpoint() string {
	fake.appSSHEndpointMutex.Lock()
	ret, specificReturn := fake.appSSHEndpointReturnsOnCall[len(fake.appSSHEndpointArgsForCall)]
	fake.appSSHEndpointArgsForCall = append(fake.appSSHEndpointArgsForCall, struct {
	}{})
	fake.recordInvocation("AppSSHEndpoint", []interface{}{})
	fake.appSSHEndpointMutex.Unlock()
	if fake.AppSSHEndpointStub != nil {
		return fake.AppSSHEndpointStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.appSSHEndpointReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) AppSSHEndpointCallCount() int {
	fake.appSSHEndpointMutex.RLock()
	defer fake.appSSHEndpointMutex.RUnlock()
	return len(fake.appSSHEndpointArgsForCall)
}

func (fake *FakeCloudControllerClient) AppSSHEndpointCalls(stub func() string) {
	fake.appSSHEndpointMutex.Lock()
	defer fake.appSSHEndpointMutex.Unlock()
	fake.AppSSHEndpointStub = stub
}

func (fake *FakeCloudControllerClient) AppSSHEndpointReturns(result1 string) {
	fake.appSSHEndpointMutex.Lock()
	defer fake.appSSHEndpointMutex.Unlock()
	fake.AppSSHEndpointStub = nil
	fake.appSSHEndpointReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AppSSHEndpointReturnsOnCall(i int, result1 string) {
	fake.appSSHEndpointMutex.Lock()
	defer fake.appSSHEndpointMutex.Unlock()
	fake.AppSSHEndpointStub = nil
	if fake.appSSHEndpointReturnsOnCall == nil {
		fake.appSSHEndpointReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.appSSHEndpointReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprint() string {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	ret, specificReturn := fake.appSSHHostKeyFingerprintReturnsOnCall[len(fake.appSSHHostKeyFingerprintArgsForCall)]
	fake.appSSHHostKeyFingerprintArgsForCall = append(fake.appSSHHostKeyFingerprintArgsForCall, struct {
	}{})
	fake.recordInvocation("AppSSHHostKeyFingerprint", []interface{}{})
	fake.appSSHHostKeyFingerprintMutex.Unlock()
	if fake.AppSSHHostKeyFingerprintStub != nil {
		return fake.AppSSHHostKeyFingerprintStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.appSSHHostKeyFingerprintReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintCallCount() int {
	fake.appSSHHostKeyFingerprintMutex.RLock()
	defer fake.appSSHHostKeyFingerprintMutex.RUnlock()
	return len(fake.appSSHHostKeyFingerprintArgsForCall)
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintCalls(stub func() string) {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	defer fake.appSSHHostKeyFingerprintMutex.Unlock()
	fake.AppSSHHostKeyFingerprintStub = stub
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintReturns(result1 string) {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	defer fake.appSSHHostKeyFingerprintMutex.Unlock()
	fake.AppSSHHostKeyFingerprintStub = nil
	fake.appSSHHostKeyFingerprintReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) AppSSHHostKeyFingerprintReturnsOnCall(i int, result1 string) {
	fake.appSSHHostKeyFingerprintMutex.Lock()
	defer fake.appSSHHostKeyFingerprintMutex.Unlock()
	fake.AppSSHHostKeyFingerprintStub = nil
	if fake.appSSHHostKeyFingerprintReturnsOnCall == nil {
		fake.appSSHHostKeyFingerprintReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.appSSHHostKeyFingerprintReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersion() string {
	fake.cloudControllerAPIVersionMutex.Lock()
	ret, specificReturn := fake.cloudControllerAPIVersionReturnsOnCall[len(fake.cloudControllerAPIVersionArgsForCall)]
	fake.cloudControllerAPIVersionArgsForCall = append(fake.cloudControllerAPIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("CloudControllerAPIVersion", []interface{}{})
	fake.cloudControllerAPIVersionMutex.Unlock()
	if fake.CloudControllerAPIVersionStub != nil {
		return fake.CloudControllerAPIVersionStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.cloudControllerAPIVersionReturns
	return fakeReturns.result1
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionCallCount() int {
	fake.cloudControllerAPIVersionMutex.RLock()
	defer fake.cloudControllerAPIVersionMutex.RUnlock()
	return len(fake.cloudControllerAPIVersionArgsForCall)
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionCalls(stub func() string) {
	fake.cloudControllerAPIVersionMutex.Lock()
	defer fake.cloudControllerAPIVersionMutex.Unlock()
	fake.CloudControllerAPIVersionStub = stub
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionReturns(result1 string) {
	fake.cloudControllerAPIVersionMutex.Lock()
	defer fake.cloudControllerAPIVersionMutex.Unlock()
	fake.CloudControllerAPIVersionStub = nil
	fake.cloudControllerAPIVersionReturns = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) CloudControllerAPIVersionReturnsOnCall(i int, result1 string) {
	fake.cloudControllerAPIVersionMutex.Lock()
	defer fake.cloudControllerAPIVersionMutex.Unlock()
	fake.CloudControllerAPIVersionStub = nil
	if fake.cloudControllerAPIVersionReturnsOnCall == nil {
		fake.cloudControllerAPIVersionReturnsOnCall = make(map[int]struct {
			result1 string
		})
	}
	fake.cloudControllerAPIVersionReturnsOnCall[i] = struct {
		result1 string
	}{result1}
}

func (fake *FakeCloudControllerClient) CreateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) {
	fake.createApplicationMutex.Lock()
	ret, specificReturn := fake.createApplicationReturnsOnCall[len(fake.createApplicationArgsForCall)]
	fake.createApplicationArgsForCall = append(fake.createApplicationArgsForCall, struct {
		arg1 resources.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(resources.Application) (resources.Application, ccv3.Warnings, error)) {
	fake.createApplicationMutex.Lock()
	defer fake.createApplicationMutex.Unlock()
	fake.CreateApplicationStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) CreateApplicationProcessScale(arg1 string, arg2 resources.Process) (resources.Process, ccv3.Warnings, error) {
	fake.createApplicationProcessScaleMutex.Lock()
	ret, specificReturn := fake.createApplicationProcessScaleReturnsOnCall[len(fake.createApplicationProcessScaleArgsForCall)]
	fake.createApplicationProcessScaleArgsForCall = append(fake.createApplicationProcessScaleArgsForCall, struct {
		arg1 string
		arg2 resources.Process
	}{arg1, arg2})
	fake.recordInvocation("CreateApplicationProcessScale", []interface{}{arg1, arg2})
	fake.createApplicationProcessScaleMutex.Unlock()
	if fake.CreateApplicationProcessScaleStub != nil {
		return fake.CreateApplicationProcessScaleStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationProcessScaleReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleCallCount() int {
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	return len(fake.createApplicationProcessScaleArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleCalls(stub func(string, resources.Process) (resources.Process, ccv3.Warnings, error)) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleArgsForCall(i int) (string, resources.Process) {
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	argsForCall := fake.createApplicationProcessScaleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = nil
	fake.createApplicationProcessScaleReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationProcessScaleReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationProcessScaleMutex.Lock()
	defer fake.createApplicationProcessScaleMutex.Unlock()
	fake.CreateApplicationProcessScaleStub = nil
	if fake.createApplicationProcessScaleReturnsOnCall == nil {
		fake.createApplicationProcessScaleReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationProcessScaleReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationTask(arg1 string, arg2 resources.Task) (resources.Task, ccv3.Warnings, error) {
	fake.createApplicationTaskMutex.Lock()
	ret, specificReturn := fake.createApplicationTaskReturnsOnCall[len(fake.createApplicationTaskArgsForCall)]
	fake.createApplicationTaskArgsForCall = append(fake.createApplicationTaskArgsForCall, struct {
		arg1 string
		arg2 resources.Task
	}{arg1, arg2})
	fake.recordInvocation("CreateApplicationTask", []interface{}{arg1, arg2})
	fake.createApplicationTaskMutex.Unlock()
	if fake.CreateApplicationTaskStub != nil {
		return fake.CreateApplicationTaskStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationTaskReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskCallCount() int {
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	return len(fake.createApplicationTaskArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskCalls(stub func(string, resources.Task) (resources.Task, ccv3.Warnings, error)) {
	fake.createApplicationTaskMutex.Lock()
	defer fake.createApplicationTaskMutex.Unlock()
	fake.CreateApplicationTaskStub = stub
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskArgsForCall(i int) (string, resources.Task) {
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	argsForCall := fake.createApplicationTaskArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationTaskMutex.Lock()
	defer fake.createApplicationTaskMutex.Unlock()
	fake.CreateApplicationTaskStub = nil
	fake.createApplicationTaskReturns = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateApplicationTaskReturnsOnCall(i int, result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.createApplicationTaskMutex.Lock()
	defer fake.createApplicationTaskMutex.Unlock()
	fake.CreateApplicationTaskStub = nil
	if fake.createApplicationTaskReturnsOnCall == nil {
		fake.createApplicationTaskReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createApplicationTaskReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuild(arg1 resources.Build) (resources.Build, ccv3.Warnings, error) {
	fake.createBuildMutex.Lock()
	ret, specificReturn := fake.createBuildReturnsOnCall[len(fake.createBuildArgsForCall)]
	fake.createBuildArgsForCall = append(fake.createBuildArgsForCall, struct {
		arg1 resources.Build
	}{arg1})
	fake.recordInvocation("CreateBuild", []interface{}{arg1})
	fake.createBuildMutex.Unlock()
	if fake.CreateBuildStub != nil {
		return fake.CreateBuildStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createBuildReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateBuildCallCount() int {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	return len(fake.createBuildArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateBuildCalls(stub func(resources.Build) (resources.Build, ccv3.Warnings, error)) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = stub
}

func (fake *FakeCloudControllerClient) CreateBuildArgsForCall(i int) resources.Build {
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	argsForCall := fake.createBuildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateBuildReturns(result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	fake.createBuildReturns = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildReturnsOnCall(i int, result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.createBuildMutex.Lock()
	defer fake.createBuildMutex.Unlock()
	fake.CreateBuildStub = nil
	if fake.createBuildReturnsOnCall == nil {
		fake.createBuildReturnsOnCall = make(map[int]struct {
			result1 resources.Build
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createBuildReturnsOnCall[i] = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) {
	fake.createBuildpackMutex.Lock()
	ret, specificReturn := fake.createBuildpackReturnsOnCall[len(fake.createBuildpackArgsForCall)]
	fake.createBuildpackArgsForCall = append(fake.createBuildpackArgsForCall, struct {
		arg1 resources.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(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)) {
	fake.createBuildpackMutex.Lock()
	defer fake.createBuildpackMutex.Unlock()
	fake.CreateBuildpackStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) CreateDomain(arg1 resources.Domain) (resources.Domain, ccv3.Warnings, error) {
	fake.createDomainMutex.Lock()
	ret, specificReturn := fake.createDomainReturnsOnCall[len(fake.createDomainArgsForCall)]
	fake.createDomainArgsForCall = append(fake.createDomainArgsForCall, struct {
		arg1 resources.Domain
	}{arg1})
	fake.recordInvocation("CreateDomain", []interface{}{arg1})
	fake.createDomainMutex.Unlock()
	if fake.CreateDomainStub != nil {
		return fake.CreateDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateDomainCallCount() int {
	fake.createDomainMutex.RLock()
	defer fake.createDomainMutex.RUnlock()
	return len(fake.createDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateDomainCalls(stub func(resources.Domain) (resources.Domain, ccv3.Warnings, error)) {
	fake.createDomainMutex.Lock()
	defer fake.createDomainMutex.Unlock()
	fake.CreateDomainStub = stub
}

func (fake *FakeCloudControllerClient) CreateDomainArgsForCall(i int) resources.Domain {
	fake.createDomainMutex.RLock()
	defer fake.createDomainMutex.RUnlock()
	argsForCall := fake.createDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateDomainReturns(result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.createDomainMutex.Lock()
	defer fake.createDomainMutex.Unlock()
	fake.CreateDomainStub = nil
	fake.createDomainReturns = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateDomainReturnsOnCall(i int, result1 resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.createDomainMutex.Lock()
	defer fake.createDomainMutex.Unlock()
	fake.CreateDomainStub = nil
	if fake.createDomainReturnsOnCall == nil {
		fake.createDomainReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createDomainReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateIsolationSegment(arg1 resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error) {
	fake.createIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.createIsolationSegmentReturnsOnCall[len(fake.createIsolationSegmentArgsForCall)]
	fake.createIsolationSegmentArgsForCall = append(fake.createIsolationSegmentArgsForCall, struct {
		arg1 resources.IsolationSegment
	}{arg1})
	fake.recordInvocation("CreateIsolationSegment", []interface{}{arg1})
	fake.createIsolationSegmentMutex.Unlock()
	if fake.CreateIsolationSegmentStub != nil {
		return fake.CreateIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentCallCount() int {
	fake.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	return len(fake.createIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentCalls(stub func(resources.IsolationSegment) (resources.IsolationSegment, ccv3.Warnings, error)) {
	fake.createIsolationSegmentMutex.Lock()
	defer fake.createIsolationSegmentMutex.Unlock()
	fake.CreateIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentArgsForCall(i int) resources.IsolationSegment {
	fake.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	argsForCall := fake.createIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturns(result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.createIsolationSegmentMutex.Lock()
	defer fake.createIsolationSegmentMutex.Unlock()
	fake.CreateIsolationSegmentStub = nil
	fake.createIsolationSegmentReturns = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreateIsolationSegmentReturnsOnCall(i int, result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.createIsolationSegmentMutex.Lock()
	defer fake.createIsolationSegmentMutex.Unlock()
	fake.CreateIsolationSegmentStub = nil
	if fake.createIsolationSegmentReturnsOnCall == nil {
		fake.createIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreatePackage(arg1 resources.Package) (resources.Package, ccv3.Warnings, error) {
	fake.createPackageMutex.Lock()
	ret, specificReturn := fake.createPackageReturnsOnCall[len(fake.createPackageArgsForCall)]
	fake.createPackageArgsForCall = append(fake.createPackageArgsForCall, struct {
		arg1 resources.Package
	}{arg1})
	fake.recordInvocation("CreatePackage", []interface{}{arg1})
	fake.createPackageMutex.Unlock()
	if fake.CreatePackageStub != nil {
		return fake.CreatePackageStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) CreatePackageCallCount() int {
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	return len(fake.createPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) CreatePackageCalls(stub func(resources.Package) (resources.Package, ccv3.Warnings, error)) {
	fake.createPackageMutex.Lock()
	defer fake.createPackageMutex.Unlock()
	fake.CreatePackageStub = stub
}

func (fake *FakeCloudControllerClient) CreatePackageArgsForCall(i int) resources.Package {
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	argsForCall := fake.createPackageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) CreatePackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.createPackageMutex.Lock()
	defer fake.createPackageMutex.Unlock()
	fake.CreatePackageStub = nil
	fake.createPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) CreatePackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.createPackageMutex.Lock()
	defer fake.createPackageMutex.Unlock()
	fake.CreatePackageStub = nil
	if fake.createPackageReturnsOnCall == nil {
		fake.createPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.createPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteApplication(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteApplicationMutex.Lock()
	ret, specificReturn := fake.deleteApplicationReturnsOnCall[len(fake.deleteApplicationArgsForCall)]
	fake.deleteApplicationArgsForCall = append(fake.deleteApplicationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteApplication", []interface{}{arg1})
	fake.deleteApplicationMutex.Unlock()
	if fake.DeleteApplicationStub != nil {
		return fake.DeleteApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteApplicationCallCount() int {
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	return len(fake.deleteApplicationArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteApplicationCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteApplicationMutex.Lock()
	defer fake.deleteApplicationMutex.Unlock()
	fake.DeleteApplicationStub = stub
}

func (fake *FakeCloudControllerClient) DeleteApplicationArgsForCall(i int) string {
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	argsForCall := fake.deleteApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteApplicationReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteApplicationMutex.Lock()
	defer fake.deleteApplicationMutex.Unlock()
	fake.DeleteApplicationStub = nil
	fake.deleteApplicationReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteApplicationReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteApplicationMutex.Lock()
	defer fake.deleteApplicationMutex.Unlock()
	fake.DeleteApplicationStub = nil
	if fake.deleteApplicationReturnsOnCall == nil {
		fake.deleteApplicationReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteApplicationReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstance(arg1 string, arg2 string, arg3 int) (ccv3.Warnings, error) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	ret, specificReturn := fake.deleteApplicationProcessInstanceReturnsOnCall[len(fake.deleteApplicationProcessInstanceArgsForCall)]
	fake.deleteApplicationProcessInstanceArgsForCall = append(fake.deleteApplicationProcessInstanceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 int
	}{arg1, arg2, arg3})
	fake.recordInvocation("DeleteApplicationProcessInstance", []interface{}{arg1, arg2, arg3})
	fake.deleteApplicationProcessInstanceMutex.Unlock()
	if fake.DeleteApplicationProcessInstanceStub != nil {
		return fake.DeleteApplicationProcessInstanceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteApplicationProcessInstanceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceCallCount() int {
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	return len(fake.deleteApplicationProcessInstanceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceCalls(stub func(string, string, int) (ccv3.Warnings, error)) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	defer fake.deleteApplicationProcessInstanceMutex.Unlock()
	fake.DeleteApplicationProcessInstanceStub = stub
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceArgsForCall(i int) (string, string, int) {
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	argsForCall := fake.deleteApplicationProcessInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	defer fake.deleteApplicationProcessInstanceMutex.Unlock()
	fake.DeleteApplicationProcessInstanceStub = nil
	fake.deleteApplicationProcessInstanceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteApplicationProcessInstanceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteApplicationProcessInstanceMutex.Lock()
	defer fake.deleteApplicationProcessInstanceMutex.Unlock()
	fake.DeleteApplicationProcessInstanceStub = nil
	if fake.deleteApplicationProcessInstanceReturnsOnCall == nil {
		fake.deleteApplicationProcessInstanceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteApplicationProcessInstanceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteBuildpack(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteBuildpackMutex.Lock()
	ret, specificReturn := fake.deleteBuildpackReturnsOnCall[len(fake.deleteBuildpackArgsForCall)]
	fake.deleteBuildpackArgsForCall = append(fake.deleteBuildpackArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteBuildpack", []interface{}{arg1})
	fake.deleteBuildpackMutex.Unlock()
	if fake.DeleteBuildpackStub != nil {
		return fake.DeleteBuildpackStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteBuildpackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteBuildpackCallCount() int {
	fake.deleteBuildpackMutex.RLock()
	defer fake.deleteBuildpackMutex.RUnlock()
	return len(fake.deleteBuildpackArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteBuildpackCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteBuildpackMutex.Lock()
	defer fake.deleteBuildpackMutex.Unlock()
	fake.DeleteBuildpackStub = stub
}

func (fake *FakeCloudControllerClient) DeleteBuildpackArgsForCall(i int) string {
	fake.deleteBuildpackMutex.RLock()
	defer fake.deleteBuildpackMutex.RUnlock()
	argsForCall := fake.deleteBuildpackArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteBuildpackReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteBuildpackMutex.Lock()
	defer fake.deleteBuildpackMutex.Unlock()
	fake.DeleteBuildpackStub = nil
	fake.deleteBuildpackReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteBuildpackReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteBuildpackMutex.Lock()
	defer fake.deleteBuildpackMutex.Unlock()
	fake.DeleteBuildpackStub = nil
	if fake.deleteBuildpackReturnsOnCall == nil {
		fake.deleteBuildpackReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteBuildpackReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteDomain(arg1 string) (ccv3.JobURL, ccv3.Warnings, error) {
	fake.deleteDomainMutex.Lock()
	ret, specificReturn := fake.deleteDomainReturnsOnCall[len(fake.deleteDomainArgsForCall)]
	fake.deleteDomainArgsForCall = append(fake.deleteDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteDomain", []interface{}{arg1})
	fake.deleteDomainMutex.Unlock()
	if fake.DeleteDomainStub != nil {
		return fake.DeleteDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) DeleteDomainCallCount() int {
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	return len(fake.deleteDomainArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteDomainCalls(stub func(string) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = stub
}

func (fake *FakeCloudControllerClient) DeleteDomainArgsForCall(i int) string {
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	argsForCall := fake.deleteDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteDomainReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = nil
	fake.deleteDomainReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteDomainReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = nil
	if fake.deleteDomainReturnsOnCall == nil {
		fake.deleteDomainReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.deleteDomainReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegment(arg1 string) (ccv3.Warnings, error) {
	fake.deleteIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentReturnsOnCall[len(fake.deleteIsolationSegmentArgsForCall)]
	fake.deleteIsolationSegmentArgsForCall = append(fake.deleteIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteIsolationSegment", []interface{}{arg1})
	fake.deleteIsolationSegmentMutex.Unlock()
	if fake.DeleteIsolationSegmentStub != nil {
		return fake.DeleteIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentCallCount() int {
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	return len(fake.deleteIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentCalls(stub func(string) (ccv3.Warnings, error)) {
	fake.deleteIsolationSegmentMutex.Lock()
	defer fake.deleteIsolationSegmentMutex.Unlock()
	fake.DeleteIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentArgsForCall(i int) string {
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	argsForCall := fake.deleteIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentMutex.Lock()
	defer fake.deleteIsolationSegmentMutex.Unlock()
	fake.DeleteIsolationSegmentStub = nil
	fake.deleteIsolationSegmentReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentMutex.Lock()
	defer fake.deleteIsolationSegmentMutex.Unlock()
	fake.DeleteIsolationSegmentStub = nil
	if fake.deleteIsolationSegmentReturnsOnCall == nil {
		fake.deleteIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteIsolationSegmentReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganization(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentOrganizationReturnsOnCall[len(fake.deleteIsolationSegmentOrganizationArgsForCall)]
	fake.deleteIsolationSegmentOrganizationArgsForCall = append(fake.deleteIsolationSegmentOrganizationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteIsolationSegmentOrganization", []interface{}{arg1, arg2})
	fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	if fake.DeleteIsolationSegmentOrganizationStub != nil {
		return fake.DeleteIsolationSegmentOrganizationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteIsolationSegmentOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationCallCount() int {
	fake.deleteIsolationSegmentOrganizationMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock()
	return len(fake.deleteIsolationSegmentOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationStub = stub
}

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

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationStub = nil
	fake.deleteIsolationSegmentOrganizationReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteIsolationSegmentOrganizationReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteIsolationSegmentOrganizationMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationStub = nil
	if fake.deleteIsolationSegmentOrganizationReturnsOnCall == nil {
		fake.deleteIsolationSegmentOrganizationReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteIsolationSegmentOrganizationReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpace(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	ret, specificReturn := fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall[len(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall)]
	fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall = append(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteServiceInstanceRelationshipsSharedSpace", []interface{}{arg1, arg2})
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	if fake.DeleteServiceInstanceRelationshipsSharedSpaceStub != nil {
		return fake.DeleteServiceInstanceRelationshipsSharedSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteServiceInstanceRelationshipsSharedSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceCallCount() int {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RLock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RUnlock()
	return len(fake.deleteServiceInstanceRelationshipsSharedSpaceArgsForCall)
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	fake.DeleteServiceInstanceRelationshipsSharedSpaceStub = stub
}

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

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceReturns(result1 ccv3.Warnings, result2 error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	fake.DeleteServiceInstanceRelationshipsSharedSpaceStub = nil
	fake.deleteServiceInstanceRelationshipsSharedSpaceReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) DeleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Lock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.Unlock()
	fake.DeleteServiceInstanceRelationshipsSharedSpaceStub = nil
	if fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall == nil {
		fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.deleteServiceInstanceRelationshipsSharedSpaceReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizations(arg1 string, arg2 []string) (resources.RelationshipList, ccv3.Warnings, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	ret, specificReturn := fake.entitleIsolationSegmentToOrganizationsReturnsOnCall[len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)]
	fake.entitleIsolationSegmentToOrganizationsArgsForCall = append(fake.entitleIsolationSegmentToOrganizationsArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	fake.recordInvocation("EntitleIsolationSegmentToOrganizations", []interface{}{arg1, arg2Copy})
	fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	if fake.EntitleIsolationSegmentToOrganizationsStub != nil {
		return fake.EntitleIsolationSegmentToOrganizationsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.entitleIsolationSegmentToOrganizationsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsCallCount() int {
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	return len(fake.entitleIsolationSegmentToOrganizationsArgsForCall)
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsCalls(stub func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)) {
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationsStub = stub
}

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

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationsStub = nil
	fake.entitleIsolationSegmentToOrganizationsReturns = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) EntitleIsolationSegmentToOrganizationsReturnsOnCall(i int, result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.entitleIsolationSegmentToOrganizationsMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationsStub = nil
	if fake.entitleIsolationSegmentToOrganizationsReturnsOnCall == nil {
		fake.entitleIsolationSegmentToOrganizationsReturnsOnCall = make(map[int]struct {
			result1 resources.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.entitleIsolationSegmentToOrganizationsReturnsOnCall[i] = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrent(arg1 string) (resources.Droplet, ccv3.Warnings, error) {
	fake.getApplicationDropletCurrentMutex.Lock()
	ret, specificReturn := fake.getApplicationDropletCurrentReturnsOnCall[len(fake.getApplicationDropletCurrentArgsForCall)]
	fake.getApplicationDropletCurrentArgsForCall = append(fake.getApplicationDropletCurrentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationDropletCurrent", []interface{}{arg1})
	fake.getApplicationDropletCurrentMutex.Unlock()
	if fake.GetApplicationDropletCurrentStub != nil {
		return fake.GetApplicationDropletCurrentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationDropletCurrentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentCallCount() int {
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	return len(fake.getApplicationDropletCurrentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentCalls(stub func(string) (resources.Droplet, ccv3.Warnings, error)) {
	fake.getApplicationDropletCurrentMutex.Lock()
	defer fake.getApplicationDropletCurrentMutex.Unlock()
	fake.GetApplicationDropletCurrentStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentArgsForCall(i int) string {
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	argsForCall := fake.getApplicationDropletCurrentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationDropletCurrentMutex.Lock()
	defer fake.getApplicationDropletCurrentMutex.Unlock()
	fake.GetApplicationDropletCurrentStub = nil
	fake.getApplicationDropletCurrentReturns = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationDropletCurrentReturnsOnCall(i int, result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationDropletCurrentMutex.Lock()
	defer fake.getApplicationDropletCurrentMutex.Unlock()
	fake.GetApplicationDropletCurrentStub = nil
	if fake.getApplicationDropletCurrentReturnsOnCall == nil {
		fake.getApplicationDropletCurrentReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationDropletCurrentReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironment(arg1 string) (ccv3.Environment, ccv3.Warnings, error) {
	fake.getApplicationEnvironmentMutex.Lock()
	ret, specificReturn := fake.getApplicationEnvironmentReturnsOnCall[len(fake.getApplicationEnvironmentArgsForCall)]
	fake.getApplicationEnvironmentArgsForCall = append(fake.getApplicationEnvironmentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationEnvironment", []interface{}{arg1})
	fake.getApplicationEnvironmentMutex.Unlock()
	if fake.GetApplicationEnvironmentStub != nil {
		return fake.GetApplicationEnvironmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationEnvironmentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentCallCount() int {
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	return len(fake.getApplicationEnvironmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentCalls(stub func(string) (ccv3.Environment, ccv3.Warnings, error)) {
	fake.getApplicationEnvironmentMutex.Lock()
	defer fake.getApplicationEnvironmentMutex.Unlock()
	fake.GetApplicationEnvironmentStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentArgsForCall(i int) string {
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	argsForCall := fake.getApplicationEnvironmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentReturns(result1 ccv3.Environment, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationEnvironmentMutex.Lock()
	defer fake.getApplicationEnvironmentMutex.Unlock()
	fake.GetApplicationEnvironmentStub = nil
	fake.getApplicationEnvironmentReturns = struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationEnvironmentReturnsOnCall(i int, result1 ccv3.Environment, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationEnvironmentMutex.Lock()
	defer fake.getApplicationEnvironmentMutex.Unlock()
	fake.GetApplicationEnvironmentStub = nil
	if fake.getApplicationEnvironmentReturnsOnCall == nil {
		fake.getApplicationEnvironmentReturnsOnCall = make(map[int]struct {
			result1 ccv3.Environment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationEnvironmentReturnsOnCall[i] = struct {
		result1 ccv3.Environment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationManifest(arg1 string) ([]byte, ccv3.Warnings, error) {
	fake.getApplicationManifestMutex.Lock()
	ret, specificReturn := fake.getApplicationManifestReturnsOnCall[len(fake.getApplicationManifestArgsForCall)]
	fake.getApplicationManifestArgsForCall = append(fake.getApplicationManifestArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationManifest", []interface{}{arg1})
	fake.getApplicationManifestMutex.Unlock()
	if fake.GetApplicationManifestStub != nil {
		return fake.GetApplicationManifestStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationManifestReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationManifestCallCount() int {
	fake.getApplicationManifestMutex.RLock()
	defer fake.getApplicationManifestMutex.RUnlock()
	return len(fake.getApplicationManifestArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationManifestCalls(stub func(string) ([]byte, ccv3.Warnings, error)) {
	fake.getApplicationManifestMutex.Lock()
	defer fake.getApplicationManifestMutex.Unlock()
	fake.GetApplicationManifestStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationManifestArgsForCall(i int) string {
	fake.getApplicationManifestMutex.RLock()
	defer fake.getApplicationManifestMutex.RUnlock()
	argsForCall := fake.getApplicationManifestArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationManifestReturns(result1 []byte, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationManifestMutex.Lock()
	defer fake.getApplicationManifestMutex.Unlock()
	fake.GetApplicationManifestStub = nil
	fake.getApplicationManifestReturns = struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationManifestReturnsOnCall(i int, result1 []byte, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationManifestMutex.Lock()
	defer fake.getApplicationManifestMutex.Unlock()
	fake.GetApplicationManifestStub = nil
	if fake.getApplicationManifestReturnsOnCall == nil {
		fake.getApplicationManifestReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationManifestReturnsOnCall[i] = struct {
		result1 []byte
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByType(arg1 string, arg2 string) (resources.Process, ccv3.Warnings, error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	ret, specificReturn := fake.getApplicationProcessByTypeReturnsOnCall[len(fake.getApplicationProcessByTypeArgsForCall)]
	fake.getApplicationProcessByTypeArgsForCall = append(fake.getApplicationProcessByTypeArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationProcessByType", []interface{}{arg1, arg2})
	fake.getApplicationProcessByTypeMutex.Unlock()
	if fake.GetApplicationProcessByTypeStub != nil {
		return fake.GetApplicationProcessByTypeStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationProcessByTypeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeCallCount() int {
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	return len(fake.getApplicationProcessByTypeArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeCalls(stub func(string, string) (resources.Process, ccv3.Warnings, error)) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = stub
}

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

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = nil
	fake.getApplicationProcessByTypeReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessByTypeReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessByTypeMutex.Lock()
	defer fake.getApplicationProcessByTypeMutex.Unlock()
	fake.GetApplicationProcessByTypeStub = nil
	if fake.getApplicationProcessByTypeReturnsOnCall == nil {
		fake.getApplicationProcessByTypeReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessByTypeReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcesses(arg1 string) ([]resources.Process, ccv3.Warnings, error) {
	fake.getApplicationProcessesMutex.Lock()
	ret, specificReturn := fake.getApplicationProcessesReturnsOnCall[len(fake.getApplicationProcessesArgsForCall)]
	fake.getApplicationProcessesArgsForCall = append(fake.getApplicationProcessesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationProcesses", []interface{}{arg1})
	fake.getApplicationProcessesMutex.Unlock()
	if fake.GetApplicationProcessesStub != nil {
		return fake.GetApplicationProcessesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationProcessesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesCallCount() int {
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	return len(fake.getApplicationProcessesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesCalls(stub func(string) ([]resources.Process, ccv3.Warnings, error)) {
	fake.getApplicationProcessesMutex.Lock()
	defer fake.getApplicationProcessesMutex.Unlock()
	fake.GetApplicationProcessesStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesArgsForCall(i int) string {
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	argsForCall := fake.getApplicationProcessesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesReturns(result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessesMutex.Lock()
	defer fake.getApplicationProcessesMutex.Unlock()
	fake.GetApplicationProcessesStub = nil
	fake.getApplicationProcessesReturns = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationProcessesReturnsOnCall(i int, result1 []resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationProcessesMutex.Lock()
	defer fake.getApplicationProcessesMutex.Unlock()
	fake.GetApplicationProcessesStub = nil
	if fake.getApplicationProcessesReturnsOnCall == nil {
		fake.getApplicationProcessesReturnsOnCall = make(map[int]struct {
			result1 []resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessesReturnsOnCall[i] = struct {
		result1 []resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationTasks(arg1 string, arg2 ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error) {
	fake.getApplicationTasksMutex.Lock()
	ret, specificReturn := fake.getApplicationTasksReturnsOnCall[len(fake.getApplicationTasksArgsForCall)]
	fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2})
	fake.getApplicationTasksMutex.Unlock()
	if fake.GetApplicationTasksStub != nil {
		return fake.GetApplicationTasksStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationTasksReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetApplicationTasksCallCount() int {
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	return len(fake.getApplicationTasksArgsForCall)
}

func (fake *FakeCloudControllerClient) GetApplicationTasksCalls(stub func(string, ...ccv3.Query) ([]resources.Task, ccv3.Warnings, error)) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = stub
}

func (fake *FakeCloudControllerClient) GetApplicationTasksArgsForCall(i int) (string, []ccv3.Query) {
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	argsForCall := fake.getApplicationTasksArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetApplicationTasksReturns(result1 []resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = nil
	fake.getApplicationTasksReturns = struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplicationTasksReturnsOnCall(i int, result1 []resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.getApplicationTasksMutex.Lock()
	defer fake.getApplicationTasksMutex.Unlock()
	fake.GetApplicationTasksStub = nil
	if fake.getApplicationTasksReturnsOnCall == nil {
		fake.getApplicationTasksReturnsOnCall = make(map[int]struct {
			result1 []resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getApplicationTasksReturnsOnCall[i] = struct {
		result1 []resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetApplications(arg1 ...ccv3.Query) ([]resources.Application, ccv3.Warnings, error) {
	fake.getApplicationsMutex.Lock()
	ret, specificReturn := fake.getApplicationsReturnsOnCall[len(fake.getApplicationsArgsForCall)]
	fake.getApplicationsArgsForCall = append(fake.getApplicationsArgsForCall, struct {
		arg1 []ccv3.Query
	}{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(...ccv3.Query) ([]resources.Application, ccv3.Warnings, error)) {
	fake.getApplicationsMutex.Lock()
	defer fake.getApplicationsMutex.Unlock()
	fake.GetApplicationsStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) GetBuild(arg1 string) (resources.Build, ccv3.Warnings, error) {
	fake.getBuildMutex.Lock()
	ret, specificReturn := fake.getBuildReturnsOnCall[len(fake.getBuildArgsForCall)]
	fake.getBuildArgsForCall = append(fake.getBuildArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetBuild", []interface{}{arg1})
	fake.getBuildMutex.Unlock()
	if fake.GetBuildStub != nil {
		return fake.GetBuildStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getBuildReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetBuildCallCount() int {
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	return len(fake.getBuildArgsForCall)
}

func (fake *FakeCloudControllerClient) GetBuildCalls(stub func(string) (resources.Build, ccv3.Warnings, error)) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = stub
}

func (fake *FakeCloudControllerClient) GetBuildArgsForCall(i int) string {
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	argsForCall := fake.getBuildArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetBuildReturns(result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = nil
	fake.getBuildReturns = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildReturnsOnCall(i int, result1 resources.Build, result2 ccv3.Warnings, result3 error) {
	fake.getBuildMutex.Lock()
	defer fake.getBuildMutex.Unlock()
	fake.GetBuildStub = nil
	if fake.getBuildReturnsOnCall == nil {
		fake.getBuildReturnsOnCall = make(map[int]struct {
			result1 resources.Build
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getBuildReturnsOnCall[i] = struct {
		result1 resources.Build
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetBuildpacks(arg1 ...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error) {
	fake.getBuildpacksMutex.Lock()
	ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)]
	fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct {
		arg1 []ccv3.Query
	}{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(...ccv3.Query) ([]resources.Buildpack, ccv3.Warnings, error)) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) GetDomains(arg1 ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) {
	fake.getDomainsMutex.Lock()
	ret, specificReturn := fake.getDomainsReturnsOnCall[len(fake.getDomainsArgsForCall)]
	fake.getDomainsArgsForCall = append(fake.getDomainsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	fake.recordInvocation("GetDomains", []interface{}{arg1})
	fake.getDomainsMutex.Unlock()
	if fake.GetDomainsStub != nil {
		return fake.GetDomainsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDomainsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDomainsCallCount() int {
	fake.getDomainsMutex.RLock()
	defer fake.getDomainsMutex.RUnlock()
	return len(fake.getDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDomainsCalls(stub func(...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)) {
	fake.getDomainsMutex.Lock()
	defer fake.getDomainsMutex.Unlock()
	fake.GetDomainsStub = stub
}

func (fake *FakeCloudControllerClient) GetDomainsArgsForCall(i int) []ccv3.Query {
	fake.getDomainsMutex.RLock()
	defer fake.getDomainsMutex.RUnlock()
	argsForCall := fake.getDomainsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDomainsReturns(result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDomainsMutex.Lock()
	defer fake.getDomainsMutex.Unlock()
	fake.GetDomainsStub = nil
	fake.getDomainsReturns = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDomainsReturnsOnCall(i int, result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getDomainsMutex.Lock()
	defer fake.getDomainsMutex.Unlock()
	fake.GetDomainsStub = nil
	if fake.getDomainsReturnsOnCall == nil {
		fake.getDomainsReturnsOnCall = make(map[int]struct {
			result1 []resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDomainsReturnsOnCall[i] = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDroplet(arg1 string) (resources.Droplet, ccv3.Warnings, error) {
	fake.getDropletMutex.Lock()
	ret, specificReturn := fake.getDropletReturnsOnCall[len(fake.getDropletArgsForCall)]
	fake.getDropletArgsForCall = append(fake.getDropletArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetDroplet", []interface{}{arg1})
	fake.getDropletMutex.Unlock()
	if fake.GetDropletStub != nil {
		return fake.GetDropletStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDropletReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDropletCallCount() int {
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	return len(fake.getDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDropletCalls(stub func(string) (resources.Droplet, ccv3.Warnings, error)) {
	fake.getDropletMutex.Lock()
	defer fake.getDropletMutex.Unlock()
	fake.GetDropletStub = stub
}

func (fake *FakeCloudControllerClient) GetDropletArgsForCall(i int) string {
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	argsForCall := fake.getDropletArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDropletReturns(result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletMutex.Lock()
	defer fake.getDropletMutex.Unlock()
	fake.GetDropletStub = nil
	fake.getDropletReturns = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDropletReturnsOnCall(i int, result1 resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletMutex.Lock()
	defer fake.getDropletMutex.Unlock()
	fake.GetDropletStub = nil
	if fake.getDropletReturnsOnCall == nil {
		fake.getDropletReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDropletReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDroplets(arg1 ...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error) {
	fake.getDropletsMutex.Lock()
	ret, specificReturn := fake.getDropletsReturnsOnCall[len(fake.getDropletsArgsForCall)]
	fake.getDropletsArgsForCall = append(fake.getDropletsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	fake.recordInvocation("GetDroplets", []interface{}{arg1})
	fake.getDropletsMutex.Unlock()
	if fake.GetDropletsStub != nil {
		return fake.GetDropletsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDropletsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetDropletsCallCount() int {
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	return len(fake.getDropletsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetDropletsCalls(stub func(...ccv3.Query) ([]resources.Droplet, ccv3.Warnings, error)) {
	fake.getDropletsMutex.Lock()
	defer fake.getDropletsMutex.Unlock()
	fake.GetDropletsStub = stub
}

func (fake *FakeCloudControllerClient) GetDropletsArgsForCall(i int) []ccv3.Query {
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	argsForCall := fake.getDropletsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetDropletsReturns(result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletsMutex.Lock()
	defer fake.getDropletsMutex.Unlock()
	fake.GetDropletsStub = nil
	fake.getDropletsReturns = struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetDropletsReturnsOnCall(i int, result1 []resources.Droplet, result2 ccv3.Warnings, result3 error) {
	fake.getDropletsMutex.Lock()
	defer fake.getDropletsMutex.Unlock()
	fake.GetDropletsStub = nil
	if fake.getDropletsReturnsOnCall == nil {
		fake.getDropletsReturnsOnCall = make(map[int]struct {
			result1 []resources.Droplet
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getDropletsReturnsOnCall[i] = struct {
		result1 []resources.Droplet
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlag(arg1 string) (resources.FeatureFlag, ccv3.Warnings, error) {
	fake.getFeatureFlagMutex.Lock()
	ret, specificReturn := fake.getFeatureFlagReturnsOnCall[len(fake.getFeatureFlagArgsForCall)]
	fake.getFeatureFlagArgsForCall = append(fake.getFeatureFlagArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetFeatureFlag", []interface{}{arg1})
	fake.getFeatureFlagMutex.Unlock()
	if fake.GetFeatureFlagStub != nil {
		return fake.GetFeatureFlagStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getFeatureFlagReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetFeatureFlagCallCount() int {
	fake.getFeatureFlagMutex.RLock()
	defer fake.getFeatureFlagMutex.RUnlock()
	return len(fake.getFeatureFlagArgsForCall)
}

func (fake *FakeCloudControllerClient) GetFeatureFlagCalls(stub func(string) (resources.FeatureFlag, ccv3.Warnings, error)) {
	fake.getFeatureFlagMutex.Lock()
	defer fake.getFeatureFlagMutex.Unlock()
	fake.GetFeatureFlagStub = stub
}

func (fake *FakeCloudControllerClient) GetFeatureFlagArgsForCall(i int) string {
	fake.getFeatureFlagMutex.RLock()
	defer fake.getFeatureFlagMutex.RUnlock()
	argsForCall := fake.getFeatureFlagArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetFeatureFlagReturns(result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagMutex.Lock()
	defer fake.getFeatureFlagMutex.Unlock()
	fake.GetFeatureFlagStub = nil
	fake.getFeatureFlagReturns = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlagReturnsOnCall(i int, result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagMutex.Lock()
	defer fake.getFeatureFlagMutex.Unlock()
	fake.GetFeatureFlagStub = nil
	if fake.getFeatureFlagReturnsOnCall == nil {
		fake.getFeatureFlagReturnsOnCall = make(map[int]struct {
			result1 resources.FeatureFlag
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getFeatureFlagReturnsOnCall[i] = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlags() ([]resources.FeatureFlag, ccv3.Warnings, error) {
	fake.getFeatureFlagsMutex.Lock()
	ret, specificReturn := fake.getFeatureFlagsReturnsOnCall[len(fake.getFeatureFlagsArgsForCall)]
	fake.getFeatureFlagsArgsForCall = append(fake.getFeatureFlagsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetFeatureFlags", []interface{}{})
	fake.getFeatureFlagsMutex.Unlock()
	if fake.GetFeatureFlagsStub != nil {
		return fake.GetFeatureFlagsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getFeatureFlagsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsCallCount() int {
	fake.getFeatureFlagsMutex.RLock()
	defer fake.getFeatureFlagsMutex.RUnlock()
	return len(fake.getFeatureFlagsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsCalls(stub func() ([]resources.FeatureFlag, ccv3.Warnings, error)) {
	fake.getFeatureFlagsMutex.Lock()
	defer fake.getFeatureFlagsMutex.Unlock()
	fake.GetFeatureFlagsStub = stub
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsReturns(result1 []resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagsMutex.Lock()
	defer fake.getFeatureFlagsMutex.Unlock()
	fake.GetFeatureFlagsStub = nil
	fake.getFeatureFlagsReturns = struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetFeatureFlagsReturnsOnCall(i int, result1 []resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.getFeatureFlagsMutex.Lock()
	defer fake.getFeatureFlagsMutex.Unlock()
	fake.GetFeatureFlagsStub = nil
	if fake.getFeatureFlagsReturnsOnCall == nil {
		fake.getFeatureFlagsReturnsOnCall = make(map[int]struct {
			result1 []resources.FeatureFlag
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getFeatureFlagsReturnsOnCall[i] = struct {
		result1 []resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegment(arg1 string) (resources.IsolationSegment, ccv3.Warnings, error) {
	fake.getIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentReturnsOnCall[len(fake.getIsolationSegmentArgsForCall)]
	fake.getIsolationSegmentArgsForCall = append(fake.getIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetIsolationSegment", []interface{}{arg1})
	fake.getIsolationSegmentMutex.Unlock()
	if fake.GetIsolationSegmentStub != nil {
		return fake.GetIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentCallCount() int {
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	return len(fake.getIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentCalls(stub func(string) (resources.IsolationSegment, ccv3.Warnings, error)) {
	fake.getIsolationSegmentMutex.Lock()
	defer fake.getIsolationSegmentMutex.Unlock()
	fake.GetIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentArgsForCall(i int) string {
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentReturns(result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentMutex.Lock()
	defer fake.getIsolationSegmentMutex.Unlock()
	fake.GetIsolationSegmentStub = nil
	fake.getIsolationSegmentReturns = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentReturnsOnCall(i int, result1 resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentMutex.Lock()
	defer fake.getIsolationSegmentMutex.Unlock()
	fake.GetIsolationSegmentStub = nil
	if fake.getIsolationSegmentReturnsOnCall == nil {
		fake.getIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizations(arg1 string) ([]resources.Organization, ccv3.Warnings, error) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentOrganizationsReturnsOnCall[len(fake.getIsolationSegmentOrganizationsArgsForCall)]
	fake.getIsolationSegmentOrganizationsArgsForCall = append(fake.getIsolationSegmentOrganizationsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetIsolationSegmentOrganizations", []interface{}{arg1})
	fake.getIsolationSegmentOrganizationsMutex.Unlock()
	if fake.GetIsolationSegmentOrganizationsStub != nil {
		return fake.GetIsolationSegmentOrganizationsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentOrganizationsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsCallCount() int {
	fake.getIsolationSegmentOrganizationsMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsMutex.RUnlock()
	return len(fake.getIsolationSegmentOrganizationsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsCalls(stub func(string) ([]resources.Organization, ccv3.Warnings, error)) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	defer fake.getIsolationSegmentOrganizationsMutex.Unlock()
	fake.GetIsolationSegmentOrganizationsStub = stub
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsArgsForCall(i int) string {
	fake.getIsolationSegmentOrganizationsMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentOrganizationsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsReturns(result1 []resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	defer fake.getIsolationSegmentOrganizationsMutex.Unlock()
	fake.GetIsolationSegmentOrganizationsStub = nil
	fake.getIsolationSegmentOrganizationsReturns = struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentOrganizationsReturnsOnCall(i int, result1 []resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentOrganizationsMutex.Lock()
	defer fake.getIsolationSegmentOrganizationsMutex.Unlock()
	fake.GetIsolationSegmentOrganizationsStub = nil
	if fake.getIsolationSegmentOrganizationsReturnsOnCall == nil {
		fake.getIsolationSegmentOrganizationsReturnsOnCall = make(map[int]struct {
			result1 []resources.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentOrganizationsReturnsOnCall[i] = struct {
		result1 []resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegments(arg1 ...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error) {
	fake.getIsolationSegmentsMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentsReturnsOnCall[len(fake.getIsolationSegmentsArgsForCall)]
	fake.getIsolationSegmentsArgsForCall = append(fake.getIsolationSegmentsArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	fake.recordInvocation("GetIsolationSegments", []interface{}{arg1})
	fake.getIsolationSegmentsMutex.Unlock()
	if fake.GetIsolationSegmentsStub != nil {
		return fake.GetIsolationSegmentsStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsCallCount() int {
	fake.getIsolationSegmentsMutex.RLock()
	defer fake.getIsolationSegmentsMutex.RUnlock()
	return len(fake.getIsolationSegmentsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsCalls(stub func(...ccv3.Query) ([]resources.IsolationSegment, ccv3.Warnings, error)) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = stub
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsArgsForCall(i int) []ccv3.Query {
	fake.getIsolationSegmentsMutex.RLock()
	defer fake.getIsolationSegmentsMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturns(result1 []resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = nil
	fake.getIsolationSegmentsReturns = struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetIsolationSegmentsReturnsOnCall(i int, result1 []resources.IsolationSegment, result2 ccv3.Warnings, result3 error) {
	fake.getIsolationSegmentsMutex.Lock()
	defer fake.getIsolationSegmentsMutex.Unlock()
	fake.GetIsolationSegmentsStub = nil
	if fake.getIsolationSegmentsReturnsOnCall == nil {
		fake.getIsolationSegmentsReturnsOnCall = make(map[int]struct {
			result1 []resources.IsolationSegment
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentsReturnsOnCall[i] = struct {
		result1 []resources.IsolationSegment
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegment(arg1 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)]
	fake.getOrganizationDefaultIsolationSegmentArgsForCall = append(fake.getOrganizationDefaultIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationDefaultIsolationSegment", []interface{}{arg1})
	fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	if fake.GetOrganizationDefaultIsolationSegmentStub != nil {
		return fake.GetOrganizationDefaultIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationDefaultIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentCallCount() int {
	fake.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	return len(fake.getOrganizationDefaultIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentCalls(stub func(string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.GetOrganizationDefaultIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentArgsForCall(i int) string {
	fake.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	argsForCall := fake.getOrganizationDefaultIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.GetOrganizationDefaultIsolationSegmentStub = nil
	fake.getOrganizationDefaultIsolationSegmentReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.GetOrganizationDefaultIsolationSegmentStub = nil
	if fake.getOrganizationDefaultIsolationSegmentReturnsOnCall == nil {
		fake.getOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDomains(arg1 string, arg2 ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error) {
	fake.getOrganizationDomainsMutex.Lock()
	ret, specificReturn := fake.getOrganizationDomainsReturnsOnCall[len(fake.getOrganizationDomainsArgsForCall)]
	fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, struct {
		arg1 string
		arg2 []ccv3.Query
	}{arg1, arg2})
	fake.recordInvocation("GetOrganizationDomains", []interface{}{arg1, arg2})
	fake.getOrganizationDomainsMutex.Unlock()
	if fake.GetOrganizationDomainsStub != nil {
		return fake.GetOrganizationDomainsStub(arg1, arg2...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationDomainsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsCallCount() int {
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	return len(fake.getOrganizationDomainsArgsForCall)
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsCalls(stub func(string, ...ccv3.Query) ([]resources.Domain, ccv3.Warnings, error)) {
	fake.getOrganizationDomainsMutex.Lock()
	defer fake.getOrganizationDomainsMutex.Unlock()
	fake.GetOrganizationDomainsStub = stub
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsArgsForCall(i int) (string, []ccv3.Query) {
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	argsForCall := fake.getOrganizationDomainsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsReturns(result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDomainsMutex.Lock()
	defer fake.getOrganizationDomainsMutex.Unlock()
	fake.GetOrganizationDomainsStub = nil
	fake.getOrganizationDomainsReturns = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizationDomainsReturnsOnCall(i int, result1 []resources.Domain, result2 ccv3.Warnings, result3 error) {
	fake.getOrganizationDomainsMutex.Lock()
	defer fake.getOrganizationDomainsMutex.Unlock()
	fake.GetOrganizationDomainsStub = nil
	if fake.getOrganizationDomainsReturnsOnCall == nil {
		fake.getOrganizationDomainsReturnsOnCall = make(map[int]struct {
			result1 []resources.Domain
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getOrganizationDomainsReturnsOnCall[i] = struct {
		result1 []resources.Domain
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetOrganizations(arg1 ...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error) {
	fake.getOrganizationsMutex.Lock()
	ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)]
	fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct {
		arg1 []ccv3.Query
	}{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(...ccv3.Query) ([]resources.Organization, ccv3.Warnings, error)) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) GetPackage(arg1 string) (resources.Package, ccv3.Warnings, error) {
	fake.getPackageMutex.Lock()
	ret, specificReturn := fake.getPackageReturnsOnCall[len(fake.getPackageArgsForCall)]
	fake.getPackageArgsForCall = append(fake.getPackageArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetPackage", []interface{}{arg1})
	fake.getPackageMutex.Unlock()
	if fake.GetPackageStub != nil {
		return fake.GetPackageStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetPackageCallCount() int {
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	return len(fake.getPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPackageCalls(stub func(string) (resources.Package, ccv3.Warnings, error)) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = stub
}

func (fake *FakeCloudControllerClient) GetPackageArgsForCall(i int) string {
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	argsForCall := fake.getPackageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = nil
	fake.getPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackageMutex.Lock()
	defer fake.getPackageMutex.Unlock()
	fake.GetPackageStub = nil
	if fake.getPackageReturnsOnCall == nil {
		fake.getPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackages(arg1 ...ccv3.Query) ([]resources.Package, ccv3.Warnings, error) {
	fake.getPackagesMutex.Lock()
	ret, specificReturn := fake.getPackagesReturnsOnCall[len(fake.getPackagesArgsForCall)]
	fake.getPackagesArgsForCall = append(fake.getPackagesArgsForCall, struct {
		arg1 []ccv3.Query
	}{arg1})
	fake.recordInvocation("GetPackages", []interface{}{arg1})
	fake.getPackagesMutex.Unlock()
	if fake.GetPackagesStub != nil {
		return fake.GetPackagesStub(arg1...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getPackagesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetPackagesCallCount() int {
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	return len(fake.getPackagesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetPackagesCalls(stub func(...ccv3.Query) ([]resources.Package, ccv3.Warnings, error)) {
	fake.getPackagesMutex.Lock()
	defer fake.getPackagesMutex.Unlock()
	fake.GetPackagesStub = stub
}

func (fake *FakeCloudControllerClient) GetPackagesArgsForCall(i int) []ccv3.Query {
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	argsForCall := fake.getPackagesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetPackagesReturns(result1 []resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackagesMutex.Lock()
	defer fake.getPackagesMutex.Unlock()
	fake.GetPackagesStub = nil
	fake.getPackagesReturns = struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetPackagesReturnsOnCall(i int, result1 []resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.getPackagesMutex.Lock()
	defer fake.getPackagesMutex.Unlock()
	fake.GetPackagesStub = nil
	if fake.getPackagesReturnsOnCall == nil {
		fake.getPackagesReturnsOnCall = make(map[int]struct {
			result1 []resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getPackagesReturnsOnCall[i] = struct {
		result1 []resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessInstances(arg1 string) ([]ccv3.ProcessInstance, ccv3.Warnings, error) {
	fake.getProcessInstancesMutex.Lock()
	ret, specificReturn := fake.getProcessInstancesReturnsOnCall[len(fake.getProcessInstancesArgsForCall)]
	fake.getProcessInstancesArgsForCall = append(fake.getProcessInstancesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetProcessInstances", []interface{}{arg1})
	fake.getProcessInstancesMutex.Unlock()
	if fake.GetProcessInstancesStub != nil {
		return fake.GetProcessInstancesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getProcessInstancesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetProcessInstancesCallCount() int {
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	return len(fake.getProcessInstancesArgsForCall)
}

func (fake *FakeCloudControllerClient) GetProcessInstancesCalls(stub func(string) ([]ccv3.ProcessInstance, ccv3.Warnings, error)) {
	fake.getProcessInstancesMutex.Lock()
	defer fake.getProcessInstancesMutex.Unlock()
	fake.GetProcessInstancesStub = stub
}

func (fake *FakeCloudControllerClient) GetProcessInstancesArgsForCall(i int) string {
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	argsForCall := fake.getProcessInstancesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetProcessInstancesReturns(result1 []ccv3.ProcessInstance, result2 ccv3.Warnings, result3 error) {
	fake.getProcessInstancesMutex.Lock()
	defer fake.getProcessInstancesMutex.Unlock()
	fake.GetProcessInstancesStub = nil
	fake.getProcessInstancesReturns = struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetProcessInstancesReturnsOnCall(i int, result1 []ccv3.ProcessInstance, result2 ccv3.Warnings, result3 error) {
	fake.getProcessInstancesMutex.Lock()
	defer fake.getProcessInstancesMutex.Unlock()
	fake.GetProcessInstancesStub = nil
	if fake.getProcessInstancesReturnsOnCall == nil {
		fake.getProcessInstancesReturnsOnCall = make(map[int]struct {
			result1 []ccv3.ProcessInstance
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getProcessInstancesReturnsOnCall[i] = struct {
		result1 []ccv3.ProcessInstance
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetServiceInstances(arg1 ...ccv3.Query) ([]resources.ServiceInstance, ccv3.Warnings, error) {
	fake.getServiceInstancesMutex.Lock()
	ret, specificReturn := fake.getServiceInstancesReturnsOnCall[len(fake.getServiceInstancesArgsForCall)]
	fake.getServiceInstancesArgsForCall = append(fake.getServiceInstancesArgsForCall, struct {
		arg1 []ccv3.Query
	}{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(...ccv3.Query) ([]resources.ServiceInstance, ccv3.Warnings, error)) {
	fake.getServiceInstancesMutex.Lock()
	defer fake.getServiceInstancesMutex.Unlock()
	fake.GetServiceInstancesStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegment(arg1 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.getSpaceIsolationSegmentReturnsOnCall[len(fake.getSpaceIsolationSegmentArgsForCall)]
	fake.getSpaceIsolationSegmentArgsForCall = append(fake.getSpaceIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSpaceIsolationSegment", []interface{}{arg1})
	fake.getSpaceIsolationSegmentMutex.Unlock()
	if fake.GetSpaceIsolationSegmentStub != nil {
		return fake.GetSpaceIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentCallCount() int {
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	return len(fake.getSpaceIsolationSegmentArgsForCall)
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentCalls(stub func(string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	defer fake.getSpaceIsolationSegmentMutex.Unlock()
	fake.GetSpaceIsolationSegmentStub = stub
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentArgsForCall(i int) string {
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	argsForCall := fake.getSpaceIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	defer fake.getSpaceIsolationSegmentMutex.Unlock()
	fake.GetSpaceIsolationSegmentStub = nil
	fake.getSpaceIsolationSegmentReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaceIsolationSegmentReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.getSpaceIsolationSegmentMutex.Lock()
	defer fake.getSpaceIsolationSegmentMutex.Unlock()
	fake.GetSpaceIsolationSegmentStub = nil
	if fake.getSpaceIsolationSegmentReturnsOnCall == nil {
		fake.getSpaceIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.getSpaceIsolationSegmentReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) GetSpaces(arg1 ...ccv3.Query) ([]resources.Space, ccv3.Warnings, error) {
	fake.getSpacesMutex.Lock()
	ret, specificReturn := fake.getSpacesReturnsOnCall[len(fake.getSpacesArgsForCall)]
	fake.getSpacesArgsForCall = append(fake.getSpacesArgsForCall, struct {
		arg1 []ccv3.Query
	}{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(...ccv3.Query) ([]resources.Space, ccv3.Warnings, error)) {
	fake.getSpacesMutex.Lock()
	defer fake.getSpacesMutex.Unlock()
	fake.GetSpacesStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) GetStacks(arg1 ...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error) {
	fake.getStacksMutex.Lock()
	ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)]
	fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct {
		arg1 []ccv3.Query
	}{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(...ccv3.Query) ([]resources.Stack, ccv3.Warnings, error)) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) PollJob(arg1 ccv3.JobURL) (ccv3.Warnings, error) {
	fake.pollJobMutex.Lock()
	ret, specificReturn := fake.pollJobReturnsOnCall[len(fake.pollJobArgsForCall)]
	fake.pollJobArgsForCall = append(fake.pollJobArgsForCall, struct {
		arg1 ccv3.JobURL
	}{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(ccv3.JobURL) (ccv3.Warnings, error)) {
	fake.pollJobMutex.Lock()
	defer fake.pollJobMutex.Unlock()
	fake.PollJobStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) ResourceMatch(arg1 []ccv3.Resource) ([]ccv3.Resource, ccv3.Warnings, error) {
	var arg1Copy []ccv3.Resource
	if arg1 != nil {
		arg1Copy = make([]ccv3.Resource, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.resourceMatchMutex.Lock()
	ret, specificReturn := fake.resourceMatchReturnsOnCall[len(fake.resourceMatchArgsForCall)]
	fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, struct {
		arg1 []ccv3.Resource
	}{arg1Copy})
	fake.recordInvocation("ResourceMatch", []interface{}{arg1Copy})
	fake.resourceMatchMutex.Unlock()
	if fake.ResourceMatchStub != nil {
		return fake.ResourceMatchStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.resourceMatchReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) ResourceMatchCallCount() int {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	return len(fake.resourceMatchArgsForCall)
}

func (fake *FakeCloudControllerClient) ResourceMatchCalls(stub func([]ccv3.Resource) ([]ccv3.Resource, ccv3.Warnings, error)) {
	fake.resourceMatchMutex.Lock()
	defer fake.resourceMatchMutex.Unlock()
	fake.ResourceMatchStub = stub
}

func (fake *FakeCloudControllerClient) ResourceMatchArgsForCall(i int) []ccv3.Resource {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	argsForCall := fake.resourceMatchArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) ResourceMatchReturns(result1 []ccv3.Resource, result2 ccv3.Warnings, result3 error) {
	fake.resourceMatchMutex.Lock()
	defer fake.resourceMatchMutex.Unlock()
	fake.ResourceMatchStub = nil
	fake.resourceMatchReturns = struct {
		result1 []ccv3.Resource
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ResourceMatchReturnsOnCall(i int, result1 []ccv3.Resource, result2 ccv3.Warnings, result3 error) {
	fake.resourceMatchMutex.Lock()
	defer fake.resourceMatchMutex.Unlock()
	fake.ResourceMatchStub = nil
	if fake.resourceMatchReturnsOnCall == nil {
		fake.resourceMatchReturnsOnCall = make(map[int]struct {
			result1 []ccv3.Resource
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.resourceMatchReturnsOnCall[i] = struct {
		result1 []ccv3.Resource
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SetApplicationDroplet(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.setApplicationDropletMutex.Lock()
	ret, specificReturn := fake.setApplicationDropletReturnsOnCall[len(fake.setApplicationDropletArgsForCall)]
	fake.setApplicationDropletArgsForCall = append(fake.setApplicationDropletArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("SetApplicationDroplet", []interface{}{arg1, arg2})
	fake.setApplicationDropletMutex.Unlock()
	if fake.SetApplicationDropletStub != nil {
		return fake.SetApplicationDropletStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.setApplicationDropletReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) SetApplicationDropletCallCount() int {
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	return len(fake.setApplicationDropletArgsForCall)
}

func (fake *FakeCloudControllerClient) SetApplicationDropletCalls(stub func(string, string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = stub
}

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

func (fake *FakeCloudControllerClient) SetApplicationDropletReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = nil
	fake.setApplicationDropletReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SetApplicationDropletReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = nil
	if fake.setApplicationDropletReturnsOnCall == nil {
		fake.setApplicationDropletReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.setApplicationDropletReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgs(arg1 string, arg2 ccv3.SharedOrgs) (ccv3.Warnings, error) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	ret, specificReturn := fake.sharePrivateDomainToOrgsReturnsOnCall[len(fake.sharePrivateDomainToOrgsArgsForCall)]
	fake.sharePrivateDomainToOrgsArgsForCall = append(fake.sharePrivateDomainToOrgsArgsForCall, struct {
		arg1 string
		arg2 ccv3.SharedOrgs
	}{arg1, arg2})
	fake.recordInvocation("SharePrivateDomainToOrgs", []interface{}{arg1, arg2})
	fake.sharePrivateDomainToOrgsMutex.Unlock()
	if fake.SharePrivateDomainToOrgsStub != nil {
		return fake.SharePrivateDomainToOrgsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.sharePrivateDomainToOrgsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsCallCount() int {
	fake.sharePrivateDomainToOrgsMutex.RLock()
	defer fake.sharePrivateDomainToOrgsMutex.RUnlock()
	return len(fake.sharePrivateDomainToOrgsArgsForCall)
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsCalls(stub func(string, ccv3.SharedOrgs) (ccv3.Warnings, error)) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	defer fake.sharePrivateDomainToOrgsMutex.Unlock()
	fake.SharePrivateDomainToOrgsStub = stub
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsArgsForCall(i int) (string, ccv3.SharedOrgs) {
	fake.sharePrivateDomainToOrgsMutex.RLock()
	defer fake.sharePrivateDomainToOrgsMutex.RUnlock()
	argsForCall := fake.sharePrivateDomainToOrgsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsReturns(result1 ccv3.Warnings, result2 error) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	defer fake.sharePrivateDomainToOrgsMutex.Unlock()
	fake.SharePrivateDomainToOrgsStub = nil
	fake.sharePrivateDomainToOrgsReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) SharePrivateDomainToOrgsReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.sharePrivateDomainToOrgsMutex.Lock()
	defer fake.sharePrivateDomainToOrgsMutex.Unlock()
	fake.SharePrivateDomainToOrgsStub = nil
	if fake.sharePrivateDomainToOrgsReturnsOnCall == nil {
		fake.sharePrivateDomainToOrgsReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.sharePrivateDomainToOrgsReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpaces(arg1 string, arg2 []string) (resources.RelationshipList, ccv3.Warnings, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.shareServiceInstanceToSpacesMutex.Lock()
	ret, specificReturn := fake.shareServiceInstanceToSpacesReturnsOnCall[len(fake.shareServiceInstanceToSpacesArgsForCall)]
	fake.shareServiceInstanceToSpacesArgsForCall = append(fake.shareServiceInstanceToSpacesArgsForCall, struct {
		arg1 string
		arg2 []string
	}{arg1, arg2Copy})
	fake.recordInvocation("ShareServiceInstanceToSpaces", []interface{}{arg1, arg2Copy})
	fake.shareServiceInstanceToSpacesMutex.Unlock()
	if fake.ShareServiceInstanceToSpacesStub != nil {
		return fake.ShareServiceInstanceToSpacesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.shareServiceInstanceToSpacesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesCallCount() int {
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	return len(fake.shareServiceInstanceToSpacesArgsForCall)
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesCalls(stub func(string, []string) (resources.RelationshipList, ccv3.Warnings, error)) {
	fake.shareServiceInstanceToSpacesMutex.Lock()
	defer fake.shareServiceInstanceToSpacesMutex.Unlock()
	fake.ShareServiceInstanceToSpacesStub = stub
}

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

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturns(result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.shareServiceInstanceToSpacesMutex.Lock()
	defer fake.shareServiceInstanceToSpacesMutex.Unlock()
	fake.ShareServiceInstanceToSpacesStub = nil
	fake.shareServiceInstanceToSpacesReturns = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) ShareServiceInstanceToSpacesReturnsOnCall(i int, result1 resources.RelationshipList, result2 ccv3.Warnings, result3 error) {
	fake.shareServiceInstanceToSpacesMutex.Lock()
	defer fake.shareServiceInstanceToSpacesMutex.Unlock()
	fake.ShareServiceInstanceToSpacesStub = nil
	if fake.shareServiceInstanceToSpacesReturnsOnCall == nil {
		fake.shareServiceInstanceToSpacesReturnsOnCall = make(map[int]struct {
			result1 resources.RelationshipList
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.shareServiceInstanceToSpacesReturnsOnCall[i] = struct {
		result1 resources.RelationshipList
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrg(arg1 string, arg2 string) (ccv3.Warnings, error) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	ret, specificReturn := fake.unsharePrivateDomainFromOrgReturnsOnCall[len(fake.unsharePrivateDomainFromOrgArgsForCall)]
	fake.unsharePrivateDomainFromOrgArgsForCall = append(fake.unsharePrivateDomainFromOrgArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UnsharePrivateDomainFromOrg", []interface{}{arg1, arg2})
	fake.unsharePrivateDomainFromOrgMutex.Unlock()
	if fake.UnsharePrivateDomainFromOrgStub != nil {
		return fake.UnsharePrivateDomainFromOrgStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unsharePrivateDomainFromOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgCallCount() int {
	fake.unsharePrivateDomainFromOrgMutex.RLock()
	defer fake.unsharePrivateDomainFromOrgMutex.RUnlock()
	return len(fake.unsharePrivateDomainFromOrgArgsForCall)
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgCalls(stub func(string, string) (ccv3.Warnings, error)) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	defer fake.unsharePrivateDomainFromOrgMutex.Unlock()
	fake.UnsharePrivateDomainFromOrgStub = stub
}

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

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgReturns(result1 ccv3.Warnings, result2 error) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	defer fake.unsharePrivateDomainFromOrgMutex.Unlock()
	fake.UnsharePrivateDomainFromOrgStub = nil
	fake.unsharePrivateDomainFromOrgReturns = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UnsharePrivateDomainFromOrgReturnsOnCall(i int, result1 ccv3.Warnings, result2 error) {
	fake.unsharePrivateDomainFromOrgMutex.Lock()
	defer fake.unsharePrivateDomainFromOrgMutex.Unlock()
	fake.UnsharePrivateDomainFromOrgStub = nil
	if fake.unsharePrivateDomainFromOrgReturnsOnCall == nil {
		fake.unsharePrivateDomainFromOrgReturnsOnCall = make(map[int]struct {
			result1 ccv3.Warnings
			result2 error
		})
	}
	fake.unsharePrivateDomainFromOrgReturnsOnCall[i] = struct {
		result1 ccv3.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeCloudControllerClient) UpdateApplication(arg1 resources.Application) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationMutex.Lock()
	ret, specificReturn := fake.updateApplicationReturnsOnCall[len(fake.updateApplicationArgsForCall)]
	fake.updateApplicationArgsForCall = append(fake.updateApplicationArgsForCall, struct {
		arg1 resources.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(resources.Application) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationMutex.Lock()
	defer fake.updateApplicationMutex.Unlock()
	fake.UpdateApplicationStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifest(arg1 string, arg2 []byte) (ccv3.JobURL, ccv3.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateApplicationApplyManifestMutex.Lock()
	ret, specificReturn := fake.updateApplicationApplyManifestReturnsOnCall[len(fake.updateApplicationApplyManifestArgsForCall)]
	fake.updateApplicationApplyManifestArgsForCall = append(fake.updateApplicationApplyManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	fake.recordInvocation("UpdateApplicationApplyManifest", []interface{}{arg1, arg2Copy})
	fake.updateApplicationApplyManifestMutex.Unlock()
	if fake.UpdateApplicationApplyManifestStub != nil {
		return fake.UpdateApplicationApplyManifestStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationApplyManifestReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestCallCount() int {
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	return len(fake.updateApplicationApplyManifestArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestCalls(stub func(string, []byte) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateApplicationApplyManifestMutex.Lock()
	defer fake.updateApplicationApplyManifestMutex.Unlock()
	fake.UpdateApplicationApplyManifestStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestArgsForCall(i int) (string, []byte) {
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	argsForCall := fake.updateApplicationApplyManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationApplyManifestMutex.Lock()
	defer fake.updateApplicationApplyManifestMutex.Unlock()
	fake.UpdateApplicationApplyManifestStub = nil
	fake.updateApplicationApplyManifestReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationApplyManifestReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationApplyManifestMutex.Lock()
	defer fake.updateApplicationApplyManifestMutex.Unlock()
	fake.UpdateApplicationApplyManifestStub = nil
	if fake.updateApplicationApplyManifestReturnsOnCall == nil {
		fake.updateApplicationApplyManifestReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationApplyManifestReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariables(arg1 string, arg2 resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	ret, specificReturn := fake.updateApplicationEnvironmentVariablesReturnsOnCall[len(fake.updateApplicationEnvironmentVariablesArgsForCall)]
	fake.updateApplicationEnvironmentVariablesArgsForCall = append(fake.updateApplicationEnvironmentVariablesArgsForCall, struct {
		arg1 string
		arg2 resources.EnvironmentVariables
	}{arg1, arg2})
	fake.recordInvocation("UpdateApplicationEnvironmentVariables", []interface{}{arg1, arg2})
	fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	if fake.UpdateApplicationEnvironmentVariablesStub != nil {
		return fake.UpdateApplicationEnvironmentVariablesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationEnvironmentVariablesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesCallCount() int {
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	return len(fake.updateApplicationEnvironmentVariablesArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesCalls(stub func(string, resources.EnvironmentVariables) (resources.EnvironmentVariables, ccv3.Warnings, error)) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesArgsForCall(i int) (string, resources.EnvironmentVariables) {
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	argsForCall := fake.updateApplicationEnvironmentVariablesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturns(result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = nil
	fake.updateApplicationEnvironmentVariablesReturns = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationEnvironmentVariablesReturnsOnCall(i int, result1 resources.EnvironmentVariables, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationEnvironmentVariablesMutex.Lock()
	defer fake.updateApplicationEnvironmentVariablesMutex.Unlock()
	fake.UpdateApplicationEnvironmentVariablesStub = nil
	if fake.updateApplicationEnvironmentVariablesReturnsOnCall == nil {
		fake.updateApplicationEnvironmentVariablesReturnsOnCall = make(map[int]struct {
			result1 resources.EnvironmentVariables
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationEnvironmentVariablesReturnsOnCall[i] = struct {
		result1 resources.EnvironmentVariables
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestart(arg1 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationRestartMutex.Lock()
	ret, specificReturn := fake.updateApplicationRestartReturnsOnCall[len(fake.updateApplicationRestartArgsForCall)]
	fake.updateApplicationRestartArgsForCall = append(fake.updateApplicationRestartArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("UpdateApplicationRestart", []interface{}{arg1})
	fake.updateApplicationRestartMutex.Unlock()
	if fake.UpdateApplicationRestartStub != nil {
		return fake.UpdateApplicationRestartStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationRestartReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartCallCount() int {
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	return len(fake.updateApplicationRestartArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartCalls(stub func(string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationRestartMutex.Lock()
	defer fake.updateApplicationRestartMutex.Unlock()
	fake.UpdateApplicationRestartStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartArgsForCall(i int) string {
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	argsForCall := fake.updateApplicationRestartArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationRestartMutex.Lock()
	defer fake.updateApplicationRestartMutex.Unlock()
	fake.UpdateApplicationRestartStub = nil
	fake.updateApplicationRestartReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationRestartReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationRestartMutex.Lock()
	defer fake.updateApplicationRestartMutex.Unlock()
	fake.UpdateApplicationRestartStub = nil
	if fake.updateApplicationRestartReturnsOnCall == nil {
		fake.updateApplicationRestartReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationRestartReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStart(arg1 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationStartMutex.Lock()
	ret, specificReturn := fake.updateApplicationStartReturnsOnCall[len(fake.updateApplicationStartArgsForCall)]
	fake.updateApplicationStartArgsForCall = append(fake.updateApplicationStartArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("UpdateApplicationStart", []interface{}{arg1})
	fake.updateApplicationStartMutex.Unlock()
	if fake.UpdateApplicationStartStub != nil {
		return fake.UpdateApplicationStartStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationStartReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartCallCount() int {
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	return len(fake.updateApplicationStartArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartCalls(stub func(string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationStartMutex.Lock()
	defer fake.updateApplicationStartMutex.Unlock()
	fake.UpdateApplicationStartStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartArgsForCall(i int) string {
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	argsForCall := fake.updateApplicationStartArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStartMutex.Lock()
	defer fake.updateApplicationStartMutex.Unlock()
	fake.UpdateApplicationStartStub = nil
	fake.updateApplicationStartReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStartReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStartMutex.Lock()
	defer fake.updateApplicationStartMutex.Unlock()
	fake.UpdateApplicationStartStub = nil
	if fake.updateApplicationStartReturnsOnCall == nil {
		fake.updateApplicationStartReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationStartReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStop(arg1 string) (resources.Application, ccv3.Warnings, error) {
	fake.updateApplicationStopMutex.Lock()
	ret, specificReturn := fake.updateApplicationStopReturnsOnCall[len(fake.updateApplicationStopArgsForCall)]
	fake.updateApplicationStopArgsForCall = append(fake.updateApplicationStopArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("UpdateApplicationStop", []interface{}{arg1})
	fake.updateApplicationStopMutex.Unlock()
	if fake.UpdateApplicationStopStub != nil {
		return fake.UpdateApplicationStopStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateApplicationStopReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopCallCount() int {
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	return len(fake.updateApplicationStopArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopCalls(stub func(string) (resources.Application, ccv3.Warnings, error)) {
	fake.updateApplicationStopMutex.Lock()
	defer fake.updateApplicationStopMutex.Unlock()
	fake.UpdateApplicationStopStub = stub
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopArgsForCall(i int) string {
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	argsForCall := fake.updateApplicationStopArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopReturns(result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStopMutex.Lock()
	defer fake.updateApplicationStopMutex.Unlock()
	fake.UpdateApplicationStopStub = nil
	fake.updateApplicationStopReturns = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateApplicationStopReturnsOnCall(i int, result1 resources.Application, result2 ccv3.Warnings, result3 error) {
	fake.updateApplicationStopMutex.Lock()
	defer fake.updateApplicationStopMutex.Unlock()
	fake.UpdateApplicationStopStub = nil
	if fake.updateApplicationStopReturnsOnCall == nil {
		fake.updateApplicationStopReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateApplicationStopReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error) {
	fake.updateBuildpackMutex.Lock()
	ret, specificReturn := fake.updateBuildpackReturnsOnCall[len(fake.updateBuildpackArgsForCall)]
	fake.updateBuildpackArgsForCall = append(fake.updateBuildpackArgsForCall, struct {
		arg1 resources.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(resources.Buildpack) (resources.Buildpack, ccv3.Warnings, error)) {
	fake.updateBuildpackMutex.Lock()
	defer fake.updateBuildpackMutex.Unlock()
	fake.UpdateBuildpackStub = stub
}

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

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

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

func (fake *FakeCloudControllerClient) UpdateFeatureFlag(arg1 resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error) {
	fake.updateFeatureFlagMutex.Lock()
	ret, specificReturn := fake.updateFeatureFlagReturnsOnCall[len(fake.updateFeatureFlagArgsForCall)]
	fake.updateFeatureFlagArgsForCall = append(fake.updateFeatureFlagArgsForCall, struct {
		arg1 resources.FeatureFlag
	}{arg1})
	fake.recordInvocation("UpdateFeatureFlag", []interface{}{arg1})
	fake.updateFeatureFlagMutex.Unlock()
	if fake.UpdateFeatureFlagStub != nil {
		return fake.UpdateFeatureFlagStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateFeatureFlagReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagCallCount() int {
	fake.updateFeatureFlagMutex.RLock()
	defer fake.updateFeatureFlagMutex.RUnlock()
	return len(fake.updateFeatureFlagArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagCalls(stub func(resources.FeatureFlag) (resources.FeatureFlag, ccv3.Warnings, error)) {
	fake.updateFeatureFlagMutex.Lock()
	defer fake.updateFeatureFlagMutex.Unlock()
	fake.UpdateFeatureFlagStub = stub
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagArgsForCall(i int) resources.FeatureFlag {
	fake.updateFeatureFlagMutex.RLock()
	defer fake.updateFeatureFlagMutex.RUnlock()
	argsForCall := fake.updateFeatureFlagArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagReturns(result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.updateFeatureFlagMutex.Lock()
	defer fake.updateFeatureFlagMutex.Unlock()
	fake.UpdateFeatureFlagStub = nil
	fake.updateFeatureFlagReturns = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateFeatureFlagReturnsOnCall(i int, result1 resources.FeatureFlag, result2 ccv3.Warnings, result3 error) {
	fake.updateFeatureFlagMutex.Lock()
	defer fake.updateFeatureFlagMutex.Unlock()
	fake.UpdateFeatureFlagStub = nil
	if fake.updateFeatureFlagReturnsOnCall == nil {
		fake.updateFeatureFlagReturnsOnCall = make(map[int]struct {
			result1 resources.FeatureFlag
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateFeatureFlagReturnsOnCall[i] = struct {
		result1 resources.FeatureFlag
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganization(arg1 resources.Organization) (resources.Organization, ccv3.Warnings, error) {
	fake.updateOrganizationMutex.Lock()
	ret, specificReturn := fake.updateOrganizationReturnsOnCall[len(fake.updateOrganizationArgsForCall)]
	fake.updateOrganizationArgsForCall = append(fake.updateOrganizationArgsForCall, struct {
		arg1 resources.Organization
	}{arg1})
	fake.recordInvocation("UpdateOrganization", []interface{}{arg1})
	fake.updateOrganizationMutex.Unlock()
	if fake.UpdateOrganizationStub != nil {
		return fake.UpdateOrganizationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateOrganizationCallCount() int {
	fake.updateOrganizationMutex.RLock()
	defer fake.updateOrganizationMutex.RUnlock()
	return len(fake.updateOrganizationArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationCalls(stub func(resources.Organization) (resources.Organization, ccv3.Warnings, error)) {
	fake.updateOrganizationMutex.Lock()
	defer fake.updateOrganizationMutex.Unlock()
	fake.UpdateOrganizationStub = stub
}

func (fake *FakeCloudControllerClient) UpdateOrganizationArgsForCall(i int) resources.Organization {
	fake.updateOrganizationMutex.RLock()
	defer fake.updateOrganizationMutex.RUnlock()
	argsForCall := fake.updateOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateOrganizationReturns(result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationMutex.Lock()
	defer fake.updateOrganizationMutex.Unlock()
	fake.UpdateOrganizationStub = nil
	fake.updateOrganizationReturns = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationReturnsOnCall(i int, result1 resources.Organization, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationMutex.Lock()
	defer fake.updateOrganizationMutex.Unlock()
	fake.UpdateOrganizationStub = nil
	if fake.updateOrganizationReturnsOnCall == nil {
		fake.updateOrganizationReturnsOnCall = make(map[int]struct {
			result1 resources.Organization
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateOrganizationReturnsOnCall[i] = struct {
		result1 resources.Organization
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationship(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	ret, specificReturn := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall[len(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall)]
	fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall = append(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrganizationDefaultIsolationSegmentRelationship", []interface{}{arg1, arg2})
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	if fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub != nil {
		return fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateOrganizationDefaultIsolationSegmentRelationshipReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipCallCount() int {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock()
	return len(fake.updateOrganizationDefaultIsolationSegmentRelationshipArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipCalls(stub func(string, string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub = stub
}

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

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub = nil
	fake.updateOrganizationDefaultIsolationSegmentRelationshipReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateOrganizationDefaultIsolationSegmentRelationshipStub = nil
	if fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall == nil {
		fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateOrganizationDefaultIsolationSegmentRelationshipReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateProcess(arg1 resources.Process) (resources.Process, ccv3.Warnings, error) {
	fake.updateProcessMutex.Lock()
	ret, specificReturn := fake.updateProcessReturnsOnCall[len(fake.updateProcessArgsForCall)]
	fake.updateProcessArgsForCall = append(fake.updateProcessArgsForCall, struct {
		arg1 resources.Process
	}{arg1})
	fake.recordInvocation("UpdateProcess", []interface{}{arg1})
	fake.updateProcessMutex.Unlock()
	if fake.UpdateProcessStub != nil {
		return fake.UpdateProcessStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateProcessReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateProcessCallCount() int {
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	return len(fake.updateProcessArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateProcessCalls(stub func(resources.Process) (resources.Process, ccv3.Warnings, error)) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = stub
}

func (fake *FakeCloudControllerClient) UpdateProcessArgsForCall(i int) resources.Process {
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	argsForCall := fake.updateProcessArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateProcessReturns(result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = nil
	fake.updateProcessReturns = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateProcessReturnsOnCall(i int, result1 resources.Process, result2 ccv3.Warnings, result3 error) {
	fake.updateProcessMutex.Lock()
	defer fake.updateProcessMutex.Unlock()
	fake.UpdateProcessStub = nil
	if fake.updateProcessReturnsOnCall == nil {
		fake.updateProcessReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateProcessReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifest(arg1 string, arg2 []byte, arg3 ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.updateSpaceApplyManifestMutex.Lock()
	ret, specificReturn := fake.updateSpaceApplyManifestReturnsOnCall[len(fake.updateSpaceApplyManifestArgsForCall)]
	fake.updateSpaceApplyManifestArgsForCall = append(fake.updateSpaceApplyManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
		arg3 []ccv3.Query
	}{arg1, arg2Copy, arg3})
	fake.recordInvocation("UpdateSpaceApplyManifest", []interface{}{arg1, arg2Copy, arg3})
	fake.updateSpaceApplyManifestMutex.Unlock()
	if fake.UpdateSpaceApplyManifestStub != nil {
		return fake.UpdateSpaceApplyManifestStub(arg1, arg2, arg3...)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateSpaceApplyManifestReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestCallCount() int {
	fake.updateSpaceApplyManifestMutex.RLock()
	defer fake.updateSpaceApplyManifestMutex.RUnlock()
	return len(fake.updateSpaceApplyManifestArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestCalls(stub func(string, []byte, ...ccv3.Query) (ccv3.JobURL, ccv3.Warnings, error)) {
	fake.updateSpaceApplyManifestMutex.Lock()
	defer fake.updateSpaceApplyManifestMutex.Unlock()
	fake.UpdateSpaceApplyManifestStub = stub
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestArgsForCall(i int) (string, []byte, []ccv3.Query) {
	fake.updateSpaceApplyManifestMutex.RLock()
	defer fake.updateSpaceApplyManifestMutex.RUnlock()
	argsForCall := fake.updateSpaceApplyManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestReturns(result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceApplyManifestMutex.Lock()
	defer fake.updateSpaceApplyManifestMutex.Unlock()
	fake.UpdateSpaceApplyManifestStub = nil
	fake.updateSpaceApplyManifestReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceApplyManifestReturnsOnCall(i int, result1 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceApplyManifestMutex.Lock()
	defer fake.updateSpaceApplyManifestMutex.Unlock()
	fake.UpdateSpaceApplyManifestStub = nil
	if fake.updateSpaceApplyManifestReturnsOnCall == nil {
		fake.updateSpaceApplyManifestReturnsOnCall = make(map[int]struct {
			result1 ccv3.JobURL
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSpaceApplyManifestReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationship(arg1 string, arg2 string) (resources.Relationship, ccv3.Warnings, error) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	ret, specificReturn := fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall[len(fake.updateSpaceIsolationSegmentRelationshipArgsForCall)]
	fake.updateSpaceIsolationSegmentRelationshipArgsForCall = append(fake.updateSpaceIsolationSegmentRelationshipArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSpaceIsolationSegmentRelationship", []interface{}{arg1, arg2})
	fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	if fake.UpdateSpaceIsolationSegmentRelationshipStub != nil {
		return fake.UpdateSpaceIsolationSegmentRelationshipStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateSpaceIsolationSegmentRelationshipReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipCallCount() int {
	fake.updateSpaceIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock()
	return len(fake.updateSpaceIsolationSegmentRelationshipArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipCalls(stub func(string, string) (resources.Relationship, ccv3.Warnings, error)) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateSpaceIsolationSegmentRelationshipStub = stub
}

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

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipReturns(result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateSpaceIsolationSegmentRelationshipStub = nil
	fake.updateSpaceIsolationSegmentRelationshipReturns = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateSpaceIsolationSegmentRelationshipReturnsOnCall(i int, result1 resources.Relationship, result2 ccv3.Warnings, result3 error) {
	fake.updateSpaceIsolationSegmentRelationshipMutex.Lock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.Unlock()
	fake.UpdateSpaceIsolationSegmentRelationshipStub = nil
	if fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall == nil {
		fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall = make(map[int]struct {
			result1 resources.Relationship
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateSpaceIsolationSegmentRelationshipReturnsOnCall[i] = struct {
		result1 resources.Relationship
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTaskCancel(arg1 string) (resources.Task, ccv3.Warnings, error) {
	fake.updateTaskCancelMutex.Lock()
	ret, specificReturn := fake.updateTaskCancelReturnsOnCall[len(fake.updateTaskCancelArgsForCall)]
	fake.updateTaskCancelArgsForCall = append(fake.updateTaskCancelArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("UpdateTaskCancel", []interface{}{arg1})
	fake.updateTaskCancelMutex.Unlock()
	if fake.UpdateTaskCancelStub != nil {
		return fake.UpdateTaskCancelStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateTaskCancelReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelCallCount() int {
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	return len(fake.updateTaskCancelArgsForCall)
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelCalls(stub func(string) (resources.Task, ccv3.Warnings, error)) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = stub
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelArgsForCall(i int) string {
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	argsForCall := fake.updateTaskCancelArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelReturns(result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = nil
	fake.updateTaskCancelReturns = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UpdateTaskCancelReturnsOnCall(i int, result1 resources.Task, result2 ccv3.Warnings, result3 error) {
	fake.updateTaskCancelMutex.Lock()
	defer fake.updateTaskCancelMutex.Unlock()
	fake.UpdateTaskCancelStub = nil
	if fake.updateTaskCancelReturnsOnCall == nil {
		fake.updateTaskCancelReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.updateTaskCancelReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBitsPackage(arg1 resources.Package, arg2 []ccv3.Resource, arg3 io.Reader, arg4 int64) (resources.Package, ccv3.Warnings, error) {
	var arg2Copy []ccv3.Resource
	if arg2 != nil {
		arg2Copy = make([]ccv3.Resource, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.uploadBitsPackageMutex.Lock()
	ret, specificReturn := fake.uploadBitsPackageReturnsOnCall[len(fake.uploadBitsPackageArgsForCall)]
	fake.uploadBitsPackageArgsForCall = append(fake.uploadBitsPackageArgsForCall, struct {
		arg1 resources.Package
		arg2 []ccv3.Resource
		arg3 io.Reader
		arg4 int64
	}{arg1, arg2Copy, arg3, arg4})
	fake.recordInvocation("UploadBitsPackage", []interface{}{arg1, arg2Copy, arg3, arg4})
	fake.uploadBitsPackageMutex.Unlock()
	if fake.UploadBitsPackageStub != nil {
		return fake.UploadBitsPackageStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadBitsPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadBitsPackageCallCount() int {
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	return len(fake.uploadBitsPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadBitsPackageCalls(stub func(resources.Package, []ccv3.Resource, io.Reader, int64) (resources.Package, ccv3.Warnings, error)) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadBitsPackageArgsForCall(i int) (resources.Package, []ccv3.Resource, io.Reader, int64) {
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	argsForCall := fake.uploadBitsPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeCloudControllerClient) UploadBitsPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = nil
	fake.uploadBitsPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBitsPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = nil
	if fake.uploadBitsPackageReturnsOnCall == nil {
		fake.uploadBitsPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadBitsPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadBuildpack(arg1 string, arg2 string, arg3 io.Reader, arg4 int64) (ccv3.JobURL, ccv3.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, ret.result3
	}
	fakeReturns := fake.uploadBuildpackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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) (ccv3.JobURL, ccv3.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 ccv3.JobURL, result2 ccv3.Warnings, result3 error) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = nil
	fake.uploadBuildpackReturns = struct {
		result1 ccv3.JobURL
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeCloudControllerClient) UploadPackage(arg1 resources.Package, arg2 string) (resources.Package, ccv3.Warnings, error) {
	fake.uploadPackageMutex.Lock()
	ret, specificReturn := fake.uploadPackageReturnsOnCall[len(fake.uploadPackageArgsForCall)]
	fake.uploadPackageArgsForCall = append(fake.uploadPackageArgsForCall, struct {
		arg1 resources.Package
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UploadPackage", []interface{}{arg1, arg2})
	fake.uploadPackageMutex.Unlock()
	if fake.UploadPackageStub != nil {
		return fake.UploadPackageStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeCloudControllerClient) UploadPackageCallCount() int {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	return len(fake.uploadPackageArgsForCall)
}

func (fake *FakeCloudControllerClient) UploadPackageCalls(stub func(resources.Package, string) (resources.Package, ccv3.Warnings, error)) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = stub
}

func (fake *FakeCloudControllerClient) UploadPackageArgsForCall(i int) (resources.Package, string) {
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.RUnlock()
	argsForCall := fake.uploadPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeCloudControllerClient) UploadPackageReturns(result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = nil
	fake.uploadPackageReturns = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) UploadPackageReturnsOnCall(i int, result1 resources.Package, result2 ccv3.Warnings, result3 error) {
	fake.uploadPackageMutex.Lock()
	defer fake.uploadPackageMutex.Unlock()
	fake.UploadPackageStub = nil
	if fake.uploadPackageReturnsOnCall == nil {
		fake.uploadPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 ccv3.Warnings
			result3 error
		})
	}
	fake.uploadPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 ccv3.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeCloudControllerClient) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.appSSHEndpointMutex.RLock()
	defer fake.appSSHEndpointMutex.RUnlock()
	fake.appSSHHostKeyFingerprintMutex.RLock()
	defer fake.appSSHHostKeyFingerprintMutex.RUnlock()
	fake.cloudControllerAPIVersionMutex.RLock()
	defer fake.cloudControllerAPIVersionMutex.RUnlock()
	fake.createApplicationMutex.RLock()
	defer fake.createApplicationMutex.RUnlock()
	fake.createApplicationProcessScaleMutex.RLock()
	defer fake.createApplicationProcessScaleMutex.RUnlock()
	fake.createApplicationTaskMutex.RLock()
	defer fake.createApplicationTaskMutex.RUnlock()
	fake.createBuildMutex.RLock()
	defer fake.createBuildMutex.RUnlock()
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	fake.createDomainMutex.RLock()
	defer fake.createDomainMutex.RUnlock()
	fake.createIsolationSegmentMutex.RLock()
	defer fake.createIsolationSegmentMutex.RUnlock()
	fake.createPackageMutex.RLock()
	defer fake.createPackageMutex.RUnlock()
	fake.deleteApplicationMutex.RLock()
	defer fake.deleteApplicationMutex.RUnlock()
	fake.deleteApplicationProcessInstanceMutex.RLock()
	defer fake.deleteApplicationProcessInstanceMutex.RUnlock()
	fake.deleteBuildpackMutex.RLock()
	defer fake.deleteBuildpackMutex.RUnlock()
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	fake.deleteIsolationSegmentMutex.RLock()
	defer fake.deleteIsolationSegmentMutex.RUnlock()
	fake.deleteIsolationSegmentOrganizationMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationMutex.RUnlock()
	fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RLock()
	defer fake.deleteServiceInstanceRelationshipsSharedSpaceMutex.RUnlock()
	fake.entitleIsolationSegmentToOrganizationsMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationsMutex.RUnlock()
	fake.getApplicationDropletCurrentMutex.RLock()
	defer fake.getApplicationDropletCurrentMutex.RUnlock()
	fake.getApplicationEnvironmentMutex.RLock()
	defer fake.getApplicationEnvironmentMutex.RUnlock()
	fake.getApplicationManifestMutex.RLock()
	defer fake.getApplicationManifestMutex.RUnlock()
	fake.getApplicationProcessByTypeMutex.RLock()
	defer fake.getApplicationProcessByTypeMutex.RUnlock()
	fake.getApplicationProcessesMutex.RLock()
	defer fake.getApplicationProcessesMutex.RUnlock()
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	fake.getApplicationsMutex.RLock()
	defer fake.getApplicationsMutex.RUnlock()
	fake.getBuildMutex.RLock()
	defer fake.getBuildMutex.RUnlock()
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	fake.getDomainsMutex.RLock()
	defer fake.getDomainsMutex.RUnlock()
	fake.getDropletMutex.RLock()
	defer fake.getDropletMutex.RUnlock()
	fake.getDropletsMutex.RLock()
	defer fake.getDropletsMutex.RUnlock()
	fake.getFeatureFlagMutex.RLock()
	defer fake.getFeatureFlagMutex.RUnlock()
	fake.getFeatureFlagsMutex.RLock()
	defer fake.getFeatureFlagsMutex.RUnlock()
	fake.getIsolationSegmentMutex.RLock()
	defer fake.getIsolationSegmentMutex.RUnlock()
	fake.getIsolationSegmentOrganizationsMutex.RLock()
	defer fake.getIsolationSegmentOrganizationsMutex.RUnlock()
	fake.getIsolationSegmentsMutex.RLock()
	defer fake.getIsolationSegmentsMutex.RUnlock()
	fake.getOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.getOrganizationDefaultIsolationSegmentMutex.RUnlock()
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getPackageMutex.RLock()
	defer fake.getPackageMutex.RUnlock()
	fake.getPackagesMutex.RLock()
	defer fake.getPackagesMutex.RUnlock()
	fake.getProcessInstancesMutex.RLock()
	defer fake.getProcessInstancesMutex.RUnlock()
	fake.getServiceInstancesMutex.RLock()
	defer fake.getServiceInstancesMutex.RUnlock()
	fake.getSpaceIsolationSegmentMutex.RLock()
	defer fake.getSpaceIsolationSegmentMutex.RUnlock()
	fake.getSpacesMutex.RLock()
	defer fake.getSpacesMutex.RUnlock()
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	fake.pollJobMutex.RLock()
	defer fake.pollJobMutex.RUnlock()
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	fake.sharePrivateDomainToOrgsMutex.RLock()
	defer fake.sharePrivateDomainToOrgsMutex.RUnlock()
	fake.shareServiceInstanceToSpacesMutex.RLock()
	defer fake.shareServiceInstanceToSpacesMutex.RUnlock()
	fake.unsharePrivateDomainFromOrgMutex.RLock()
	defer fake.unsharePrivateDomainFromOrgMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.updateApplicationApplyManifestMutex.RLock()
	defer fake.updateApplicationApplyManifestMutex.RUnlock()
	fake.updateApplicationEnvironmentVariablesMutex.RLock()
	defer fake.updateApplicationEnvironmentVariablesMutex.RUnlock()
	fake.updateApplicationRestartMutex.RLock()
	defer fake.updateApplicationRestartMutex.RUnlock()
	fake.updateApplicationStartMutex.RLock()
	defer fake.updateApplicationStartMutex.RUnlock()
	fake.updateApplicationStopMutex.RLock()
	defer fake.updateApplicationStopMutex.RUnlock()
	fake.updateBuildpackMutex.RLock()
	defer fake.updateBuildpackMutex.RUnlock()
	fake.updateFeatureFlagMutex.RLock()
	defer fake.updateFeatureFlagMutex.RUnlock()
	fake.updateOrganizationMutex.RLock()
	defer fake.updateOrganizationMutex.RUnlock()
	fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateOrganizationDefaultIsolationSegmentRelationshipMutex.RUnlock()
	fake.updateProcessMutex.RLock()
	defer fake.updateProcessMutex.RUnlock()
	fake.updateSpaceApplyManifestMutex.RLock()
	defer fake.updateSpaceApplyManifestMutex.RUnlock()
	fake.updateSpaceIsolationSegmentRelationshipMutex.RLock()
	defer fake.updateSpaceIsolationSegmentRelationshipMutex.RUnlock()
	fake.updateTaskCancelMutex.RLock()
	defer fake.updateTaskCancelMutex.RUnlock()
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	fake.uploadPackageMutex.RLock()
	defer fake.uploadPackageMutex.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 _ v7action.CloudControllerClient = new(FakeCloudControllerClient)