github.com/DaAlbrecht/cf-cli@v0.0.0-20231128151943-1fe19bb400b9/command/v7/v7fakes/fake_actor.go

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

import (
	"context"
	"io"
	"net/http"
	"sync"
	"time"

	"code.cloudfoundry.org/cli/actor/sharedaction"
	"code.cloudfoundry.org/cli/actor/v7action"
	"code.cloudfoundry.org/cli/api/cloudcontroller/ccv3"
	constanta "code.cloudfoundry.org/cli/api/cloudcontroller/ccv3/constant"
	"code.cloudfoundry.org/cli/api/uaa/constant"
	"code.cloudfoundry.org/cli/cf/configuration/coreconfig"
	v7 "code.cloudfoundry.org/cli/command/v7"
	"code.cloudfoundry.org/cli/resources"
	"code.cloudfoundry.org/cli/types"
	"code.cloudfoundry.org/cli/util/configv3"
	"github.com/SermoDigital/jose/jwt"
)

type FakeActor struct {
	ApplyOrganizationQuotaByNameStub        func(string, string) (v7action.Warnings, error)
	applyOrganizationQuotaByNameMutex       sync.RWMutex
	applyOrganizationQuotaByNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	applyOrganizationQuotaByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	applyOrganizationQuotaByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	ApplySpaceQuotaByNameStub        func(string, string, string) (v7action.Warnings, error)
	applySpaceQuotaByNameMutex       sync.RWMutex
	applySpaceQuotaByNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	applySpaceQuotaByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	applySpaceQuotaByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	AssignIsolationSegmentToSpaceByNameAndSpaceStub        func(string, string) (v7action.Warnings, error)
	assignIsolationSegmentToSpaceByNameAndSpaceMutex       sync.RWMutex
	assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	assignIsolationSegmentToSpaceByNameAndSpaceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	assignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	AuthenticateStub        func(map[string]string, string, constant.GrantType) error
	authenticateMutex       sync.RWMutex
	authenticateArgsForCall []struct {
		arg1 map[string]string
		arg2 string
		arg3 constant.GrantType
	}
	authenticateReturns struct {
		result1 error
	}
	authenticateReturnsOnCall map[int]struct {
		result1 error
	}
	BindSecurityGroupToSpacesStub        func(string, []resources.Space, constanta.SecurityGroupLifecycle) (v7action.Warnings, error)
	bindSecurityGroupToSpacesMutex       sync.RWMutex
	bindSecurityGroupToSpacesArgsForCall []struct {
		arg1 string
		arg2 []resources.Space
		arg3 constanta.SecurityGroupLifecycle
	}
	bindSecurityGroupToSpacesReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	bindSecurityGroupToSpacesReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CancelDeploymentStub        func(string) (v7action.Warnings, error)
	cancelDeploymentMutex       sync.RWMutex
	cancelDeploymentArgsForCall []struct {
		arg1 string
	}
	cancelDeploymentReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	cancelDeploymentReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CheckRouteStub        func(string, string, string, int) (bool, v7action.Warnings, error)
	checkRouteMutex       sync.RWMutex
	checkRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}
	checkRouteReturns struct {
		result1 bool
		result2 v7action.Warnings
		result3 error
	}
	checkRouteReturnsOnCall map[int]struct {
		result1 bool
		result2 v7action.Warnings
		result3 error
	}
	ClearTargetStub        func()
	clearTargetMutex       sync.RWMutex
	clearTargetArgsForCall []struct {
	}
	CopyPackageStub        func(resources.Application, resources.Application) (resources.Package, v7action.Warnings, error)
	copyPackageMutex       sync.RWMutex
	copyPackageArgsForCall []struct {
		arg1 resources.Application
		arg2 resources.Application
	}
	copyPackageReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	copyPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	CreateAndUploadBitsPackageByApplicationNameAndSpaceStub        func(string, string, string) (resources.Package, v7action.Warnings, error)
	createAndUploadBitsPackageByApplicationNameAndSpaceMutex       sync.RWMutex
	createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	createAndUploadBitsPackageByApplicationNameAndSpaceReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	createAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	CreateApplicationDropletStub        func(string) (resources.Droplet, v7action.Warnings, error)
	createApplicationDropletMutex       sync.RWMutex
	createApplicationDropletArgsForCall []struct {
		arg1 string
	}
	createApplicationDropletReturns struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}
	createApplicationDropletReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}
	CreateApplicationInSpaceStub        func(resources.Application, string) (resources.Application, v7action.Warnings, error)
	createApplicationInSpaceMutex       sync.RWMutex
	createApplicationInSpaceArgsForCall []struct {
		arg1 resources.Application
		arg2 string
	}
	createApplicationInSpaceReturns struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	createApplicationInSpaceReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	CreateBitsPackageByApplicationStub        func(string) (resources.Package, v7action.Warnings, error)
	createBitsPackageByApplicationMutex       sync.RWMutex
	createBitsPackageByApplicationArgsForCall []struct {
		arg1 string
	}
	createBitsPackageByApplicationReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	createBitsPackageByApplicationReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	CreateBuildpackStub        func(resources.Buildpack) (resources.Buildpack, v7action.Warnings, error)
	createBuildpackMutex       sync.RWMutex
	createBuildpackArgsForCall []struct {
		arg1 resources.Buildpack
	}
	createBuildpackReturns struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	createBuildpackReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	CreateDeploymentByApplicationAndDropletStub        func(string, string) (string, v7action.Warnings, error)
	createDeploymentByApplicationAndDropletMutex       sync.RWMutex
	createDeploymentByApplicationAndDropletArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createDeploymentByApplicationAndDropletReturns struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	createDeploymentByApplicationAndDropletReturnsOnCall map[int]struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	CreateDeploymentByApplicationAndRevisionStub        func(string, string) (string, v7action.Warnings, error)
	createDeploymentByApplicationAndRevisionMutex       sync.RWMutex
	createDeploymentByApplicationAndRevisionArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createDeploymentByApplicationAndRevisionReturns struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	createDeploymentByApplicationAndRevisionReturnsOnCall map[int]struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	CreateDockerPackageByApplicationStub        func(string, v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error)
	createDockerPackageByApplicationMutex       sync.RWMutex
	createDockerPackageByApplicationArgsForCall []struct {
		arg1 string
		arg2 v7action.DockerImageCredentials
	}
	createDockerPackageByApplicationReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	createDockerPackageByApplicationReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	CreateDockerPackageByApplicationNameAndSpaceStub        func(string, string, v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error)
	createDockerPackageByApplicationNameAndSpaceMutex       sync.RWMutex
	createDockerPackageByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 v7action.DockerImageCredentials
	}
	createDockerPackageByApplicationNameAndSpaceReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	createDockerPackageByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	CreateIsolationSegmentByNameStub        func(resources.IsolationSegment) (v7action.Warnings, error)
	createIsolationSegmentByNameMutex       sync.RWMutex
	createIsolationSegmentByNameArgsForCall []struct {
		arg1 resources.IsolationSegment
	}
	createIsolationSegmentByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createIsolationSegmentByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateManagedServiceInstanceStub        func(v7action.CreateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	createManagedServiceInstanceMutex       sync.RWMutex
	createManagedServiceInstanceArgsForCall []struct {
		arg1 v7action.CreateManagedServiceInstanceParams
	}
	createManagedServiceInstanceReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	createManagedServiceInstanceReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	CreateOrgRoleStub        func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error)
	createOrgRoleMutex       sync.RWMutex
	createOrgRoleArgsForCall []struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 bool
	}
	createOrgRoleReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createOrgRoleReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateOrganizationStub        func(string) (resources.Organization, v7action.Warnings, error)
	createOrganizationMutex       sync.RWMutex
	createOrganizationArgsForCall []struct {
		arg1 string
	}
	createOrganizationReturns struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	createOrganizationReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	CreateOrganizationQuotaStub        func(string, v7action.QuotaLimits) (v7action.Warnings, error)
	createOrganizationQuotaMutex       sync.RWMutex
	createOrganizationQuotaArgsForCall []struct {
		arg1 string
		arg2 v7action.QuotaLimits
	}
	createOrganizationQuotaReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createOrganizationQuotaReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreatePrivateDomainStub        func(string, string) (v7action.Warnings, error)
	createPrivateDomainMutex       sync.RWMutex
	createPrivateDomainArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createPrivateDomainReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createPrivateDomainReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateRouteStub        func(string, string, string, string, int) (resources.Route, v7action.Warnings, error)
	createRouteMutex       sync.RWMutex
	createRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 int
	}
	createRouteReturns struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}
	createRouteReturnsOnCall map[int]struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}
	CreateRouteBindingStub        func(v7action.CreateRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	createRouteBindingMutex       sync.RWMutex
	createRouteBindingArgsForCall []struct {
		arg1 v7action.CreateRouteBindingParams
	}
	createRouteBindingReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	createRouteBindingReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	CreateSecurityGroupStub        func(string, string) (v7action.Warnings, error)
	createSecurityGroupMutex       sync.RWMutex
	createSecurityGroupArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createSecurityGroupReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createSecurityGroupReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateServiceAppBindingStub        func(v7action.CreateServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	createServiceAppBindingMutex       sync.RWMutex
	createServiceAppBindingArgsForCall []struct {
		arg1 v7action.CreateServiceAppBindingParams
	}
	createServiceAppBindingReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	createServiceAppBindingReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	CreateServiceBrokerStub        func(resources.ServiceBroker) (v7action.Warnings, error)
	createServiceBrokerMutex       sync.RWMutex
	createServiceBrokerArgsForCall []struct {
		arg1 resources.ServiceBroker
	}
	createServiceBrokerReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createServiceBrokerReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateServiceKeyStub        func(v7action.CreateServiceKeyParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	createServiceKeyMutex       sync.RWMutex
	createServiceKeyArgsForCall []struct {
		arg1 v7action.CreateServiceKeyParams
	}
	createServiceKeyReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	createServiceKeyReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	CreateSharedDomainStub        func(string, bool, string) (v7action.Warnings, error)
	createSharedDomainMutex       sync.RWMutex
	createSharedDomainArgsForCall []struct {
		arg1 string
		arg2 bool
		arg3 string
	}
	createSharedDomainReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createSharedDomainReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateSpaceStub        func(string, string) (resources.Space, v7action.Warnings, error)
	createSpaceMutex       sync.RWMutex
	createSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	createSpaceReturns struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}
	createSpaceReturnsOnCall map[int]struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}
	CreateSpaceQuotaStub        func(string, string, v7action.QuotaLimits) (v7action.Warnings, error)
	createSpaceQuotaMutex       sync.RWMutex
	createSpaceQuotaArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 v7action.QuotaLimits
	}
	createSpaceQuotaReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createSpaceQuotaReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateSpaceRoleStub        func(constanta.RoleType, string, string, string, string, bool) (v7action.Warnings, error)
	createSpaceRoleMutex       sync.RWMutex
	createSpaceRoleArgsForCall []struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 string
		arg6 bool
	}
	createSpaceRoleReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createSpaceRoleReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	CreateUserStub        func(string, string, string) (resources.User, v7action.Warnings, error)
	createUserMutex       sync.RWMutex
	createUserArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	createUserReturns struct {
		result1 resources.User
		result2 v7action.Warnings
		result3 error
	}
	createUserReturnsOnCall map[int]struct {
		result1 resources.User
		result2 v7action.Warnings
		result3 error
	}
	CreateUserProvidedServiceInstanceStub        func(resources.ServiceInstance) (v7action.Warnings, error)
	createUserProvidedServiceInstanceMutex       sync.RWMutex
	createUserProvidedServiceInstanceArgsForCall []struct {
		arg1 resources.ServiceInstance
	}
	createUserProvidedServiceInstanceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	createUserProvidedServiceInstanceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteApplicationByNameAndSpaceStub        func(string, string, bool) (v7action.Warnings, error)
	deleteApplicationByNameAndSpaceMutex       sync.RWMutex
	deleteApplicationByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	deleteApplicationByNameAndSpaceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteApplicationByNameAndSpaceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteBuildpackByNameAndStackStub        func(string, string) (v7action.Warnings, error)
	deleteBuildpackByNameAndStackMutex       sync.RWMutex
	deleteBuildpackByNameAndStackArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteBuildpackByNameAndStackReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteBuildpackByNameAndStackReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteDomainStub        func(resources.Domain) (v7action.Warnings, error)
	deleteDomainMutex       sync.RWMutex
	deleteDomainArgsForCall []struct {
		arg1 resources.Domain
	}
	deleteDomainReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteDomainReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub        func(string, string, string, int) (v7action.Warnings, error)
	deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex       sync.RWMutex
	deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}
	deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteIsolationSegmentByNameStub        func(string) (v7action.Warnings, error)
	deleteIsolationSegmentByNameMutex       sync.RWMutex
	deleteIsolationSegmentByNameArgsForCall []struct {
		arg1 string
	}
	deleteIsolationSegmentByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteIsolationSegmentByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteIsolationSegmentOrganizationByNameStub        func(string, string) (v7action.Warnings, error)
	deleteIsolationSegmentOrganizationByNameMutex       sync.RWMutex
	deleteIsolationSegmentOrganizationByNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteIsolationSegmentOrganizationByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteIsolationSegmentOrganizationByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteOrgRoleStub        func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error)
	deleteOrgRoleMutex       sync.RWMutex
	deleteOrgRoleArgsForCall []struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 bool
	}
	deleteOrgRoleReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteOrgRoleReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteOrganizationStub        func(string) (v7action.Warnings, error)
	deleteOrganizationMutex       sync.RWMutex
	deleteOrganizationArgsForCall []struct {
		arg1 string
	}
	deleteOrganizationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteOrganizationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteOrganizationQuotaStub        func(string) (v7action.Warnings, error)
	deleteOrganizationQuotaMutex       sync.RWMutex
	deleteOrganizationQuotaArgsForCall []struct {
		arg1 string
	}
	deleteOrganizationQuotaReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteOrganizationQuotaReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteOrphanedRoutesStub        func(string) (v7action.Warnings, error)
	deleteOrphanedRoutesMutex       sync.RWMutex
	deleteOrphanedRoutesArgsForCall []struct {
		arg1 string
	}
	deleteOrphanedRoutesReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteOrphanedRoutesReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteRouteStub        func(string, string, string, int) (v7action.Warnings, error)
	deleteRouteMutex       sync.RWMutex
	deleteRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}
	deleteRouteReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteRouteReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteRouteBindingStub        func(v7action.DeleteRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	deleteRouteBindingMutex       sync.RWMutex
	deleteRouteBindingArgsForCall []struct {
		arg1 v7action.DeleteRouteBindingParams
	}
	deleteRouteBindingReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	deleteRouteBindingReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	DeleteSecurityGroupStub        func(string) (v7action.Warnings, error)
	deleteSecurityGroupMutex       sync.RWMutex
	deleteSecurityGroupArgsForCall []struct {
		arg1 string
	}
	deleteSecurityGroupReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteSecurityGroupReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteServiceAppBindingStub        func(v7action.DeleteServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	deleteServiceAppBindingMutex       sync.RWMutex
	deleteServiceAppBindingArgsForCall []struct {
		arg1 v7action.DeleteServiceAppBindingParams
	}
	deleteServiceAppBindingReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	deleteServiceAppBindingReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	DeleteServiceBrokerStub        func(string) (v7action.Warnings, error)
	deleteServiceBrokerMutex       sync.RWMutex
	deleteServiceBrokerArgsForCall []struct {
		arg1 string
	}
	deleteServiceBrokerReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteServiceBrokerReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteServiceInstanceStub        func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error)
	deleteServiceInstanceMutex       sync.RWMutex
	deleteServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteServiceInstanceReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	deleteServiceInstanceReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	DeleteServiceKeyByServiceInstanceAndNameStub        func(string, string, string) (chan v7action.PollJobEvent, v7action.Warnings, error)
	deleteServiceKeyByServiceInstanceAndNameMutex       sync.RWMutex
	deleteServiceKeyByServiceInstanceAndNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	deleteServiceKeyByServiceInstanceAndNameReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	deleteServiceKeyByServiceInstanceAndNameReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	DeleteSpaceByNameAndOrganizationNameStub        func(string, string) (v7action.Warnings, error)
	deleteSpaceByNameAndOrganizationNameMutex       sync.RWMutex
	deleteSpaceByNameAndOrganizationNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteSpaceByNameAndOrganizationNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteSpaceByNameAndOrganizationNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteSpaceQuotaByNameStub        func(string, string) (v7action.Warnings, error)
	deleteSpaceQuotaByNameMutex       sync.RWMutex
	deleteSpaceQuotaByNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteSpaceQuotaByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteSpaceQuotaByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteSpaceRoleStub        func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error)
	deleteSpaceRoleMutex       sync.RWMutex
	deleteSpaceRoleArgsForCall []struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 bool
	}
	deleteSpaceRoleReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteSpaceRoleReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DeleteUserStub        func(string) (v7action.Warnings, error)
	deleteUserMutex       sync.RWMutex
	deleteUserArgsForCall []struct {
		arg1 string
	}
	deleteUserReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteUserReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DiffSpaceManifestStub        func(string, []byte) (resources.ManifestDiff, v7action.Warnings, error)
	diffSpaceManifestMutex       sync.RWMutex
	diffSpaceManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	diffSpaceManifestReturns struct {
		result1 resources.ManifestDiff
		result2 v7action.Warnings
		result3 error
	}
	diffSpaceManifestReturnsOnCall map[int]struct {
		result1 resources.ManifestDiff
		result2 v7action.Warnings
		result3 error
	}
	DisableFeatureFlagStub        func(string) (v7action.Warnings, error)
	disableFeatureFlagMutex       sync.RWMutex
	disableFeatureFlagArgsForCall []struct {
		arg1 string
	}
	disableFeatureFlagReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	disableFeatureFlagReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	DisableServiceAccessStub        func(string, string, string, string) (v7action.SkippedPlans, v7action.Warnings, error)
	disableServiceAccessMutex       sync.RWMutex
	disableServiceAccessArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}
	disableServiceAccessReturns struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}
	disableServiceAccessReturnsOnCall map[int]struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}
	DownloadCurrentDropletByAppNameStub        func(string, string) ([]byte, string, v7action.Warnings, error)
	downloadCurrentDropletByAppNameMutex       sync.RWMutex
	downloadCurrentDropletByAppNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	downloadCurrentDropletByAppNameReturns struct {
		result1 []byte
		result2 string
		result3 v7action.Warnings
		result4 error
	}
	downloadCurrentDropletByAppNameReturnsOnCall map[int]struct {
		result1 []byte
		result2 string
		result3 v7action.Warnings
		result4 error
	}
	DownloadDropletByGUIDAndAppNameStub        func(string, string, string) ([]byte, v7action.Warnings, error)
	downloadDropletByGUIDAndAppNameMutex       sync.RWMutex
	downloadDropletByGUIDAndAppNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	downloadDropletByGUIDAndAppNameReturns struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}
	downloadDropletByGUIDAndAppNameReturnsOnCall map[int]struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}
	EnableFeatureFlagStub        func(string) (v7action.Warnings, error)
	enableFeatureFlagMutex       sync.RWMutex
	enableFeatureFlagArgsForCall []struct {
		arg1 string
	}
	enableFeatureFlagReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	enableFeatureFlagReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	EnableServiceAccessStub        func(string, string, string, string) (v7action.SkippedPlans, v7action.Warnings, error)
	enableServiceAccessMutex       sync.RWMutex
	enableServiceAccessArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}
	enableServiceAccessReturns struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}
	enableServiceAccessReturnsOnCall map[int]struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}
	EntitleIsolationSegmentToOrganizationByNameStub        func(string, string) (v7action.Warnings, error)
	entitleIsolationSegmentToOrganizationByNameMutex       sync.RWMutex
	entitleIsolationSegmentToOrganizationByNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	entitleIsolationSegmentToOrganizationByNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	entitleIsolationSegmentToOrganizationByNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	GetAppFeatureStub        func(string, string) (resources.ApplicationFeature, v7action.Warnings, error)
	getAppFeatureMutex       sync.RWMutex
	getAppFeatureArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getAppFeatureReturns struct {
		result1 resources.ApplicationFeature
		result2 v7action.Warnings
		result3 error
	}
	getAppFeatureReturnsOnCall map[int]struct {
		result1 resources.ApplicationFeature
		result2 v7action.Warnings
		result3 error
	}
	GetAppSummariesForSpaceStub        func(string, string) ([]v7action.ApplicationSummary, v7action.Warnings, error)
	getAppSummariesForSpaceMutex       sync.RWMutex
	getAppSummariesForSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getAppSummariesForSpaceReturns struct {
		result1 []v7action.ApplicationSummary
		result2 v7action.Warnings
		result3 error
	}
	getAppSummariesForSpaceReturnsOnCall map[int]struct {
		result1 []v7action.ApplicationSummary
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationByNameAndSpaceStub        func(string, string) (resources.Application, v7action.Warnings, error)
	getApplicationByNameAndSpaceMutex       sync.RWMutex
	getApplicationByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationByNameAndSpaceReturns struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	getApplicationByNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationDropletsStub        func(string, string) ([]resources.Droplet, v7action.Warnings, error)
	getApplicationDropletsMutex       sync.RWMutex
	getApplicationDropletsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationDropletsReturns struct {
		result1 []resources.Droplet
		result2 v7action.Warnings
		result3 error
	}
	getApplicationDropletsReturnsOnCall map[int]struct {
		result1 []resources.Droplet
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationLabelsStub        func(string, string) (map[string]types.NullString, v7action.Warnings, error)
	getApplicationLabelsMutex       sync.RWMutex
	getApplicationLabelsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getApplicationLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationMapForRouteStub        func(resources.Route) (map[string]resources.Application, v7action.Warnings, error)
	getApplicationMapForRouteMutex       sync.RWMutex
	getApplicationMapForRouteArgsForCall []struct {
		arg1 resources.Route
	}
	getApplicationMapForRouteReturns struct {
		result1 map[string]resources.Application
		result2 v7action.Warnings
		result3 error
	}
	getApplicationMapForRouteReturnsOnCall map[int]struct {
		result1 map[string]resources.Application
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationPackagesStub        func(string, string) ([]resources.Package, v7action.Warnings, error)
	getApplicationPackagesMutex       sync.RWMutex
	getApplicationPackagesArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationPackagesReturns struct {
		result1 []resources.Package
		result2 v7action.Warnings
		result3 error
	}
	getApplicationPackagesReturnsOnCall map[int]struct {
		result1 []resources.Package
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationProcessHealthChecksByNameAndSpaceStub        func(string, string) ([]v7action.ProcessHealthCheck, v7action.Warnings, error)
	getApplicationProcessHealthChecksByNameAndSpaceMutex       sync.RWMutex
	getApplicationProcessHealthChecksByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationProcessHealthChecksByNameAndSpaceReturns struct {
		result1 []v7action.ProcessHealthCheck
		result2 v7action.Warnings
		result3 error
	}
	getApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall map[int]struct {
		result1 []v7action.ProcessHealthCheck
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationRevisionsDeployedStub        func(string) ([]resources.Revision, v7action.Warnings, error)
	getApplicationRevisionsDeployedMutex       sync.RWMutex
	getApplicationRevisionsDeployedArgsForCall []struct {
		arg1 string
	}
	getApplicationRevisionsDeployedReturns struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}
	getApplicationRevisionsDeployedReturnsOnCall map[int]struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationRoutesStub        func(string) ([]resources.Route, v7action.Warnings, error)
	getApplicationRoutesMutex       sync.RWMutex
	getApplicationRoutesArgsForCall []struct {
		arg1 string
	}
	getApplicationRoutesReturns struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}
	getApplicationRoutesReturnsOnCall map[int]struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationTasksStub        func(string, v7action.SortOrder) ([]resources.Task, v7action.Warnings, error)
	getApplicationTasksMutex       sync.RWMutex
	getApplicationTasksArgsForCall []struct {
		arg1 string
		arg2 v7action.SortOrder
	}
	getApplicationTasksReturns struct {
		result1 []resources.Task
		result2 v7action.Warnings
		result3 error
	}
	getApplicationTasksReturnsOnCall map[int]struct {
		result1 []resources.Task
		result2 v7action.Warnings
		result3 error
	}
	GetApplicationsByNamesAndSpaceStub        func([]string, string) ([]resources.Application, v7action.Warnings, error)
	getApplicationsByNamesAndSpaceMutex       sync.RWMutex
	getApplicationsByNamesAndSpaceArgsForCall []struct {
		arg1 []string
		arg2 string
	}
	getApplicationsByNamesAndSpaceReturns struct {
		result1 []resources.Application
		result2 v7action.Warnings
		result3 error
	}
	getApplicationsByNamesAndSpaceReturnsOnCall map[int]struct {
		result1 []resources.Application
		result2 v7action.Warnings
		result3 error
	}
	GetBuildpackLabelsStub        func(string, string) (map[string]types.NullString, v7action.Warnings, error)
	getBuildpackLabelsMutex       sync.RWMutex
	getBuildpackLabelsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getBuildpackLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getBuildpackLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetBuildpacksStub        func(string) ([]resources.Buildpack, v7action.Warnings, error)
	getBuildpacksMutex       sync.RWMutex
	getBuildpacksArgsForCall []struct {
		arg1 string
	}
	getBuildpacksReturns struct {
		result1 []resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	getBuildpacksReturnsOnCall map[int]struct {
		result1 []resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	GetCurrentUserStub        func() (configv3.User, error)
	getCurrentUserMutex       sync.RWMutex
	getCurrentUserArgsForCall []struct {
	}
	getCurrentUserReturns struct {
		result1 configv3.User
		result2 error
	}
	getCurrentUserReturnsOnCall map[int]struct {
		result1 configv3.User
		result2 error
	}
	GetDefaultDomainStub        func(string) (resources.Domain, v7action.Warnings, error)
	getDefaultDomainMutex       sync.RWMutex
	getDefaultDomainArgsForCall []struct {
		arg1 string
	}
	getDefaultDomainReturns struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	getDefaultDomainReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	GetDetailedAppSummaryStub        func(string, string, bool) (v7action.DetailedApplicationSummary, v7action.Warnings, error)
	getDetailedAppSummaryMutex       sync.RWMutex
	getDetailedAppSummaryArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	getDetailedAppSummaryReturns struct {
		result1 v7action.DetailedApplicationSummary
		result2 v7action.Warnings
		result3 error
	}
	getDetailedAppSummaryReturnsOnCall map[int]struct {
		result1 v7action.DetailedApplicationSummary
		result2 v7action.Warnings
		result3 error
	}
	GetDomainStub        func(string) (resources.Domain, v7action.Warnings, error)
	getDomainMutex       sync.RWMutex
	getDomainArgsForCall []struct {
		arg1 string
	}
	getDomainReturns struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	getDomainReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	GetDomainByNameStub        func(string) (resources.Domain, v7action.Warnings, error)
	getDomainByNameMutex       sync.RWMutex
	getDomainByNameArgsForCall []struct {
		arg1 string
	}
	getDomainByNameReturns struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	getDomainByNameReturnsOnCall map[int]struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	GetDomainLabelsStub        func(string) (map[string]types.NullString, v7action.Warnings, error)
	getDomainLabelsMutex       sync.RWMutex
	getDomainLabelsArgsForCall []struct {
		arg1 string
	}
	getDomainLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getDomainLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetEffectiveIsolationSegmentBySpaceStub        func(string, string) (resources.IsolationSegment, v7action.Warnings, error)
	getEffectiveIsolationSegmentBySpaceMutex       sync.RWMutex
	getEffectiveIsolationSegmentBySpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getEffectiveIsolationSegmentBySpaceReturns struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}
	getEffectiveIsolationSegmentBySpaceReturnsOnCall map[int]struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}
	GetEnvironmentVariableGroupStub        func(constanta.EnvironmentVariableGroupName) (v7action.EnvironmentVariableGroup, v7action.Warnings, error)
	getEnvironmentVariableGroupMutex       sync.RWMutex
	getEnvironmentVariableGroupArgsForCall []struct {
		arg1 constanta.EnvironmentVariableGroupName
	}
	getEnvironmentVariableGroupReturns struct {
		result1 v7action.EnvironmentVariableGroup
		result2 v7action.Warnings
		result3 error
	}
	getEnvironmentVariableGroupReturnsOnCall map[int]struct {
		result1 v7action.EnvironmentVariableGroup
		result2 v7action.Warnings
		result3 error
	}
	GetEnvironmentVariablesByApplicationNameAndSpaceStub        func(string, string) (v7action.EnvironmentVariableGroups, v7action.Warnings, error)
	getEnvironmentVariablesByApplicationNameAndSpaceMutex       sync.RWMutex
	getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getEnvironmentVariablesByApplicationNameAndSpaceReturns struct {
		result1 v7action.EnvironmentVariableGroups
		result2 v7action.Warnings
		result3 error
	}
	getEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 v7action.EnvironmentVariableGroups
		result2 v7action.Warnings
		result3 error
	}
	GetFeatureFlagByNameStub        func(string) (resources.FeatureFlag, v7action.Warnings, error)
	getFeatureFlagByNameMutex       sync.RWMutex
	getFeatureFlagByNameArgsForCall []struct {
		arg1 string
	}
	getFeatureFlagByNameReturns struct {
		result1 resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}
	getFeatureFlagByNameReturnsOnCall map[int]struct {
		result1 resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}
	GetFeatureFlagsStub        func() ([]resources.FeatureFlag, v7action.Warnings, error)
	getFeatureFlagsMutex       sync.RWMutex
	getFeatureFlagsArgsForCall []struct {
	}
	getFeatureFlagsReturns struct {
		result1 []resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}
	getFeatureFlagsReturnsOnCall map[int]struct {
		result1 []resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}
	GetGlobalRunningSecurityGroupsStub        func() ([]resources.SecurityGroup, v7action.Warnings, error)
	getGlobalRunningSecurityGroupsMutex       sync.RWMutex
	getGlobalRunningSecurityGroupsArgsForCall []struct {
	}
	getGlobalRunningSecurityGroupsReturns struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}
	getGlobalRunningSecurityGroupsReturnsOnCall map[int]struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}
	GetGlobalStagingSecurityGroupsStub        func() ([]resources.SecurityGroup, v7action.Warnings, error)
	getGlobalStagingSecurityGroupsMutex       sync.RWMutex
	getGlobalStagingSecurityGroupsArgsForCall []struct {
	}
	getGlobalStagingSecurityGroupsReturns struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}
	getGlobalStagingSecurityGroupsReturnsOnCall map[int]struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}
	GetIsolationSegmentByNameStub        func(string) (resources.IsolationSegment, v7action.Warnings, error)
	getIsolationSegmentByNameMutex       sync.RWMutex
	getIsolationSegmentByNameArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentByNameReturns struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}
	getIsolationSegmentByNameReturnsOnCall map[int]struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}
	GetIsolationSegmentSummariesStub        func() ([]v7action.IsolationSegmentSummary, v7action.Warnings, error)
	getIsolationSegmentSummariesMutex       sync.RWMutex
	getIsolationSegmentSummariesArgsForCall []struct {
	}
	getIsolationSegmentSummariesReturns struct {
		result1 []v7action.IsolationSegmentSummary
		result2 v7action.Warnings
		result3 error
	}
	getIsolationSegmentSummariesReturnsOnCall map[int]struct {
		result1 []v7action.IsolationSegmentSummary
		result2 v7action.Warnings
		result3 error
	}
	GetIsolationSegmentsByOrganizationStub        func(string) ([]resources.IsolationSegment, v7action.Warnings, error)
	getIsolationSegmentsByOrganizationMutex       sync.RWMutex
	getIsolationSegmentsByOrganizationArgsForCall []struct {
		arg1 string
	}
	getIsolationSegmentsByOrganizationReturns struct {
		result1 []resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}
	getIsolationSegmentsByOrganizationReturnsOnCall map[int]struct {
		result1 []resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}
	GetLatestActiveDeploymentForAppStub        func(string) (resources.Deployment, v7action.Warnings, error)
	getLatestActiveDeploymentForAppMutex       sync.RWMutex
	getLatestActiveDeploymentForAppArgsForCall []struct {
		arg1 string
	}
	getLatestActiveDeploymentForAppReturns struct {
		result1 resources.Deployment
		result2 v7action.Warnings
		result3 error
	}
	getLatestActiveDeploymentForAppReturnsOnCall map[int]struct {
		result1 resources.Deployment
		result2 v7action.Warnings
		result3 error
	}
	GetLoginPromptsStub        func() (map[string]coreconfig.AuthPrompt, error)
	getLoginPromptsMutex       sync.RWMutex
	getLoginPromptsArgsForCall []struct {
	}
	getLoginPromptsReturns struct {
		result1 map[string]coreconfig.AuthPrompt
		result2 error
	}
	getLoginPromptsReturnsOnCall map[int]struct {
		result1 map[string]coreconfig.AuthPrompt
		result2 error
	}
	GetNewestReadyPackageForApplicationStub        func(resources.Application) (resources.Package, v7action.Warnings, error)
	getNewestReadyPackageForApplicationMutex       sync.RWMutex
	getNewestReadyPackageForApplicationArgsForCall []struct {
		arg1 resources.Application
	}
	getNewestReadyPackageForApplicationReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	getNewestReadyPackageForApplicationReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	GetOrgUsersByRoleTypeStub        func(string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error)
	getOrgUsersByRoleTypeMutex       sync.RWMutex
	getOrgUsersByRoleTypeArgsForCall []struct {
		arg1 string
	}
	getOrgUsersByRoleTypeReturns struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}
	getOrgUsersByRoleTypeReturnsOnCall map[int]struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationByNameStub        func(string) (resources.Organization, v7action.Warnings, error)
	getOrganizationByNameMutex       sync.RWMutex
	getOrganizationByNameArgsForCall []struct {
		arg1 string
	}
	getOrganizationByNameReturns struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationByNameReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationDomainsStub        func(string, string) ([]resources.Domain, v7action.Warnings, error)
	getOrganizationDomainsMutex       sync.RWMutex
	getOrganizationDomainsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getOrganizationDomainsReturns struct {
		result1 []resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationDomainsReturnsOnCall map[int]struct {
		result1 []resources.Domain
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationLabelsStub        func(string) (map[string]types.NullString, v7action.Warnings, error)
	getOrganizationLabelsMutex       sync.RWMutex
	getOrganizationLabelsArgsForCall []struct {
		arg1 string
	}
	getOrganizationLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationQuotaByNameStub        func(string) (resources.OrganizationQuota, v7action.Warnings, error)
	getOrganizationQuotaByNameMutex       sync.RWMutex
	getOrganizationQuotaByNameArgsForCall []struct {
		arg1 string
	}
	getOrganizationQuotaByNameReturns struct {
		result1 resources.OrganizationQuota
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationQuotaByNameReturnsOnCall map[int]struct {
		result1 resources.OrganizationQuota
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationQuotasStub        func() ([]resources.OrganizationQuota, v7action.Warnings, error)
	getOrganizationQuotasMutex       sync.RWMutex
	getOrganizationQuotasArgsForCall []struct {
	}
	getOrganizationQuotasReturns struct {
		result1 []resources.OrganizationQuota
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationQuotasReturnsOnCall map[int]struct {
		result1 []resources.OrganizationQuota
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationSpacesStub        func(string) ([]resources.Space, v7action.Warnings, error)
	getOrganizationSpacesMutex       sync.RWMutex
	getOrganizationSpacesArgsForCall []struct {
		arg1 string
	}
	getOrganizationSpacesReturns struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationSpacesReturnsOnCall map[int]struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationSpacesWithLabelSelectorStub        func(string, string) ([]resources.Space, v7action.Warnings, error)
	getOrganizationSpacesWithLabelSelectorMutex       sync.RWMutex
	getOrganizationSpacesWithLabelSelectorArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getOrganizationSpacesWithLabelSelectorReturns struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationSpacesWithLabelSelectorReturnsOnCall map[int]struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationSummaryByNameStub        func(string) (v7action.OrganizationSummary, v7action.Warnings, error)
	getOrganizationSummaryByNameMutex       sync.RWMutex
	getOrganizationSummaryByNameArgsForCall []struct {
		arg1 string
	}
	getOrganizationSummaryByNameReturns struct {
		result1 v7action.OrganizationSummary
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationSummaryByNameReturnsOnCall map[int]struct {
		result1 v7action.OrganizationSummary
		result2 v7action.Warnings
		result3 error
	}
	GetOrganizationsStub        func(string) ([]resources.Organization, v7action.Warnings, error)
	getOrganizationsMutex       sync.RWMutex
	getOrganizationsArgsForCall []struct {
		arg1 string
	}
	getOrganizationsReturns struct {
		result1 []resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	getOrganizationsReturnsOnCall map[int]struct {
		result1 []resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	GetProcessByTypeAndApplicationStub        func(string, string) (resources.Process, v7action.Warnings, error)
	getProcessByTypeAndApplicationMutex       sync.RWMutex
	getProcessByTypeAndApplicationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getProcessByTypeAndApplicationReturns struct {
		result1 resources.Process
		result2 v7action.Warnings
		result3 error
	}
	getProcessByTypeAndApplicationReturnsOnCall map[int]struct {
		result1 resources.Process
		result2 v7action.Warnings
		result3 error
	}
	GetRawApplicationManifestByNameAndSpaceStub        func(string, string) ([]byte, v7action.Warnings, error)
	getRawApplicationManifestByNameAndSpaceMutex       sync.RWMutex
	getRawApplicationManifestByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getRawApplicationManifestByNameAndSpaceReturns struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}
	getRawApplicationManifestByNameAndSpaceReturnsOnCall map[int]struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}
	GetRecentEventsByApplicationNameAndSpaceStub        func(string, string) ([]v7action.Event, v7action.Warnings, error)
	getRecentEventsByApplicationNameAndSpaceMutex       sync.RWMutex
	getRecentEventsByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getRecentEventsByApplicationNameAndSpaceReturns struct {
		result1 []v7action.Event
		result2 v7action.Warnings
		result3 error
	}
	getRecentEventsByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 []v7action.Event
		result2 v7action.Warnings
		result3 error
	}
	GetRecentLogsForApplicationByNameAndSpaceStub        func(string, string, sharedaction.LogCacheClient) ([]sharedaction.LogMessage, v7action.Warnings, error)
	getRecentLogsForApplicationByNameAndSpaceMutex       sync.RWMutex
	getRecentLogsForApplicationByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 sharedaction.LogCacheClient
	}
	getRecentLogsForApplicationByNameAndSpaceReturns struct {
		result1 []sharedaction.LogMessage
		result2 v7action.Warnings
		result3 error
	}
	getRecentLogsForApplicationByNameAndSpaceReturnsOnCall map[int]struct {
		result1 []sharedaction.LogMessage
		result2 v7action.Warnings
		result3 error
	}
	GetRevisionByApplicationAndVersionStub        func(string, int) (resources.Revision, v7action.Warnings, error)
	getRevisionByApplicationAndVersionMutex       sync.RWMutex
	getRevisionByApplicationAndVersionArgsForCall []struct {
		arg1 string
		arg2 int
	}
	getRevisionByApplicationAndVersionReturns struct {
		result1 resources.Revision
		result2 v7action.Warnings
		result3 error
	}
	getRevisionByApplicationAndVersionReturnsOnCall map[int]struct {
		result1 resources.Revision
		result2 v7action.Warnings
		result3 error
	}
	GetRevisionsByApplicationNameAndSpaceStub        func(string, string) ([]resources.Revision, v7action.Warnings, error)
	getRevisionsByApplicationNameAndSpaceMutex       sync.RWMutex
	getRevisionsByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getRevisionsByApplicationNameAndSpaceReturns struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}
	getRevisionsByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}
	GetRootResponseStub        func() (v7action.Info, v7action.Warnings, error)
	getRootResponseMutex       sync.RWMutex
	getRootResponseArgsForCall []struct {
	}
	getRootResponseReturns struct {
		result1 v7action.Info
		result2 v7action.Warnings
		result3 error
	}
	getRootResponseReturnsOnCall map[int]struct {
		result1 v7action.Info
		result2 v7action.Warnings
		result3 error
	}
	GetRouteByAttributesStub        func(resources.Domain, string, string, int) (resources.Route, v7action.Warnings, error)
	getRouteByAttributesMutex       sync.RWMutex
	getRouteByAttributesArgsForCall []struct {
		arg1 resources.Domain
		arg2 string
		arg3 string
		arg4 int
	}
	getRouteByAttributesReturns struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}
	getRouteByAttributesReturnsOnCall map[int]struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}
	GetRouteDestinationByAppGUIDStub        func(resources.Route, string) (resources.RouteDestination, error)
	getRouteDestinationByAppGUIDMutex       sync.RWMutex
	getRouteDestinationByAppGUIDArgsForCall []struct {
		arg1 resources.Route
		arg2 string
	}
	getRouteDestinationByAppGUIDReturns struct {
		result1 resources.RouteDestination
		result2 error
	}
	getRouteDestinationByAppGUIDReturnsOnCall map[int]struct {
		result1 resources.RouteDestination
		result2 error
	}
	GetRouteLabelsStub        func(string, string) (map[string]types.NullString, v7action.Warnings, error)
	getRouteLabelsMutex       sync.RWMutex
	getRouteLabelsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getRouteLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getRouteLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetRouteSummariesStub        func([]resources.Route) ([]v7action.RouteSummary, v7action.Warnings, error)
	getRouteSummariesMutex       sync.RWMutex
	getRouteSummariesArgsForCall []struct {
		arg1 []resources.Route
	}
	getRouteSummariesReturns struct {
		result1 []v7action.RouteSummary
		result2 v7action.Warnings
		result3 error
	}
	getRouteSummariesReturnsOnCall map[int]struct {
		result1 []v7action.RouteSummary
		result2 v7action.Warnings
		result3 error
	}
	GetRouterGroupsStub        func() ([]v7action.RouterGroup, error)
	getRouterGroupsMutex       sync.RWMutex
	getRouterGroupsArgsForCall []struct {
	}
	getRouterGroupsReturns struct {
		result1 []v7action.RouterGroup
		result2 error
	}
	getRouterGroupsReturnsOnCall map[int]struct {
		result1 []v7action.RouterGroup
		result2 error
	}
	GetRoutesByOrgStub        func(string, string) ([]resources.Route, v7action.Warnings, error)
	getRoutesByOrgMutex       sync.RWMutex
	getRoutesByOrgArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getRoutesByOrgReturns struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}
	getRoutesByOrgReturnsOnCall map[int]struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}
	GetRoutesBySpaceStub        func(string, string) ([]resources.Route, v7action.Warnings, error)
	getRoutesBySpaceMutex       sync.RWMutex
	getRoutesBySpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getRoutesBySpaceReturns struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}
	getRoutesBySpaceReturnsOnCall map[int]struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}
	GetSSHEnabledStub        func(string) (ccv3.SSHEnabled, v7action.Warnings, error)
	getSSHEnabledMutex       sync.RWMutex
	getSSHEnabledArgsForCall []struct {
		arg1 string
	}
	getSSHEnabledReturns struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}
	getSSHEnabledReturnsOnCall map[int]struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}
	GetSSHEnabledByAppNameStub        func(string, string) (ccv3.SSHEnabled, v7action.Warnings, error)
	getSSHEnabledByAppNameMutex       sync.RWMutex
	getSSHEnabledByAppNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSSHEnabledByAppNameReturns struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}
	getSSHEnabledByAppNameReturnsOnCall map[int]struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}
	GetSSHPasscodeStub        func() (string, error)
	getSSHPasscodeMutex       sync.RWMutex
	getSSHPasscodeArgsForCall []struct {
	}
	getSSHPasscodeReturns struct {
		result1 string
		result2 error
	}
	getSSHPasscodeReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub        func(string, string, string, uint) (v7action.SSHAuthentication, v7action.Warnings, error)
	getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex       sync.RWMutex
	getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 uint
	}
	getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns struct {
		result1 v7action.SSHAuthentication
		result2 v7action.Warnings
		result3 error
	}
	getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall map[int]struct {
		result1 v7action.SSHAuthentication
		result2 v7action.Warnings
		result3 error
	}
	GetSecurityGroupStub        func(string) (resources.SecurityGroup, v7action.Warnings, error)
	getSecurityGroupMutex       sync.RWMutex
	getSecurityGroupArgsForCall []struct {
		arg1 string
	}
	getSecurityGroupReturns struct {
		result1 resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}
	getSecurityGroupReturnsOnCall map[int]struct {
		result1 resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}
	GetSecurityGroupSummaryStub        func(string) (v7action.SecurityGroupSummary, v7action.Warnings, error)
	getSecurityGroupSummaryMutex       sync.RWMutex
	getSecurityGroupSummaryArgsForCall []struct {
		arg1 string
	}
	getSecurityGroupSummaryReturns struct {
		result1 v7action.SecurityGroupSummary
		result2 v7action.Warnings
		result3 error
	}
	getSecurityGroupSummaryReturnsOnCall map[int]struct {
		result1 v7action.SecurityGroupSummary
		result2 v7action.Warnings
		result3 error
	}
	GetSecurityGroupsStub        func() ([]v7action.SecurityGroupSummary, v7action.Warnings, error)
	getSecurityGroupsMutex       sync.RWMutex
	getSecurityGroupsArgsForCall []struct {
	}
	getSecurityGroupsReturns struct {
		result1 []v7action.SecurityGroupSummary
		result2 v7action.Warnings
		result3 error
	}
	getSecurityGroupsReturnsOnCall map[int]struct {
		result1 []v7action.SecurityGroupSummary
		result2 v7action.Warnings
		result3 error
	}
	GetServiceAccessStub        func(string, string, string) ([]v7action.ServicePlanAccess, v7action.Warnings, error)
	getServiceAccessMutex       sync.RWMutex
	getServiceAccessArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getServiceAccessReturns struct {
		result1 []v7action.ServicePlanAccess
		result2 v7action.Warnings
		result3 error
	}
	getServiceAccessReturnsOnCall map[int]struct {
		result1 []v7action.ServicePlanAccess
		result2 v7action.Warnings
		result3 error
	}
	GetServiceBrokerByNameStub        func(string) (resources.ServiceBroker, v7action.Warnings, error)
	getServiceBrokerByNameMutex       sync.RWMutex
	getServiceBrokerByNameArgsForCall []struct {
		arg1 string
	}
	getServiceBrokerByNameReturns struct {
		result1 resources.ServiceBroker
		result2 v7action.Warnings
		result3 error
	}
	getServiceBrokerByNameReturnsOnCall map[int]struct {
		result1 resources.ServiceBroker
		result2 v7action.Warnings
		result3 error
	}
	GetServiceBrokerLabelsStub        func(string) (map[string]types.NullString, v7action.Warnings, error)
	getServiceBrokerLabelsMutex       sync.RWMutex
	getServiceBrokerLabelsArgsForCall []struct {
		arg1 string
	}
	getServiceBrokerLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getServiceBrokerLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetServiceBrokersStub        func() ([]resources.ServiceBroker, v7action.Warnings, error)
	getServiceBrokersMutex       sync.RWMutex
	getServiceBrokersArgsForCall []struct {
	}
	getServiceBrokersReturns struct {
		result1 []resources.ServiceBroker
		result2 v7action.Warnings
		result3 error
	}
	getServiceBrokersReturnsOnCall map[int]struct {
		result1 []resources.ServiceBroker
		result2 v7action.Warnings
		result3 error
	}
	GetServiceInstanceByNameAndSpaceStub        func(string, string) (resources.ServiceInstance, v7action.Warnings, error)
	getServiceInstanceByNameAndSpaceMutex       sync.RWMutex
	getServiceInstanceByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceInstanceByNameAndSpaceReturns struct {
		result1 resources.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}
	getServiceInstanceByNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}
	GetServiceInstanceDetailsStub        func(string, string, bool) (v7action.ServiceInstanceDetails, v7action.Warnings, error)
	getServiceInstanceDetailsMutex       sync.RWMutex
	getServiceInstanceDetailsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	getServiceInstanceDetailsReturns struct {
		result1 v7action.ServiceInstanceDetails
		result2 v7action.Warnings
		result3 error
	}
	getServiceInstanceDetailsReturnsOnCall map[int]struct {
		result1 v7action.ServiceInstanceDetails
		result2 v7action.Warnings
		result3 error
	}
	GetServiceInstanceLabelsStub        func(string, string) (map[string]types.NullString, v7action.Warnings, error)
	getServiceInstanceLabelsMutex       sync.RWMutex
	getServiceInstanceLabelsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceInstanceLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getServiceInstanceLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetServiceInstanceParametersStub        func(string, string) (v7action.ServiceInstanceParameters, v7action.Warnings, error)
	getServiceInstanceParametersMutex       sync.RWMutex
	getServiceInstanceParametersArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceInstanceParametersReturns struct {
		result1 v7action.ServiceInstanceParameters
		result2 v7action.Warnings
		result3 error
	}
	getServiceInstanceParametersReturnsOnCall map[int]struct {
		result1 v7action.ServiceInstanceParameters
		result2 v7action.Warnings
		result3 error
	}
	GetServiceInstancesForSpaceStub        func(string, bool) ([]v7action.ServiceInstance, v7action.Warnings, error)
	getServiceInstancesForSpaceMutex       sync.RWMutex
	getServiceInstancesForSpaceArgsForCall []struct {
		arg1 string
		arg2 bool
	}
	getServiceInstancesForSpaceReturns struct {
		result1 []v7action.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}
	getServiceInstancesForSpaceReturnsOnCall map[int]struct {
		result1 []v7action.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}
	GetServiceKeyByServiceInstanceAndNameStub        func(string, string, string) (resources.ServiceCredentialBinding, v7action.Warnings, error)
	getServiceKeyByServiceInstanceAndNameMutex       sync.RWMutex
	getServiceKeyByServiceInstanceAndNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getServiceKeyByServiceInstanceAndNameReturns struct {
		result1 resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}
	getServiceKeyByServiceInstanceAndNameReturnsOnCall map[int]struct {
		result1 resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}
	GetServiceKeyDetailsByServiceInstanceAndNameStub        func(string, string, string) (resources.ServiceCredentialBindingDetails, v7action.Warnings, error)
	getServiceKeyDetailsByServiceInstanceAndNameMutex       sync.RWMutex
	getServiceKeyDetailsByServiceInstanceAndNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getServiceKeyDetailsByServiceInstanceAndNameReturns struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 v7action.Warnings
		result3 error
	}
	getServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall map[int]struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 v7action.Warnings
		result3 error
	}
	GetServiceKeysByServiceInstanceStub        func(string, string) ([]resources.ServiceCredentialBinding, v7action.Warnings, error)
	getServiceKeysByServiceInstanceMutex       sync.RWMutex
	getServiceKeysByServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceKeysByServiceInstanceReturns struct {
		result1 []resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}
	getServiceKeysByServiceInstanceReturnsOnCall map[int]struct {
		result1 []resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}
	GetServiceOfferingLabelsStub        func(string, string) (map[string]types.NullString, v7action.Warnings, error)
	getServiceOfferingLabelsMutex       sync.RWMutex
	getServiceOfferingLabelsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceOfferingLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getServiceOfferingLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetServicePlanByNameOfferingAndBrokerStub        func(string, string, string) (resources.ServicePlan, v7action.Warnings, error)
	getServicePlanByNameOfferingAndBrokerMutex       sync.RWMutex
	getServicePlanByNameOfferingAndBrokerArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getServicePlanByNameOfferingAndBrokerReturns struct {
		result1 resources.ServicePlan
		result2 v7action.Warnings
		result3 error
	}
	getServicePlanByNameOfferingAndBrokerReturnsOnCall map[int]struct {
		result1 resources.ServicePlan
		result2 v7action.Warnings
		result3 error
	}
	GetServicePlanLabelsStub        func(string, string, string) (map[string]types.NullString, v7action.Warnings, error)
	getServicePlanLabelsMutex       sync.RWMutex
	getServicePlanLabelsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getServicePlanLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getServicePlanLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceByNameAndOrganizationStub        func(string, string) (resources.Space, v7action.Warnings, error)
	getSpaceByNameAndOrganizationMutex       sync.RWMutex
	getSpaceByNameAndOrganizationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSpaceByNameAndOrganizationReturns struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}
	getSpaceByNameAndOrganizationReturnsOnCall map[int]struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceFeatureStub        func(string, string, string) (bool, v7action.Warnings, error)
	getSpaceFeatureMutex       sync.RWMutex
	getSpaceFeatureArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	getSpaceFeatureReturns struct {
		result1 bool
		result2 v7action.Warnings
		result3 error
	}
	getSpaceFeatureReturnsOnCall map[int]struct {
		result1 bool
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceLabelsStub        func(string, string) (map[string]types.NullString, v7action.Warnings, error)
	getSpaceLabelsMutex       sync.RWMutex
	getSpaceLabelsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSpaceLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getSpaceLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceQuotaByNameStub        func(string, string) (resources.SpaceQuota, v7action.Warnings, error)
	getSpaceQuotaByNameMutex       sync.RWMutex
	getSpaceQuotaByNameArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSpaceQuotaByNameReturns struct {
		result1 resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}
	getSpaceQuotaByNameReturnsOnCall map[int]struct {
		result1 resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceQuotasByOrgGUIDStub        func(string) ([]resources.SpaceQuota, v7action.Warnings, error)
	getSpaceQuotasByOrgGUIDMutex       sync.RWMutex
	getSpaceQuotasByOrgGUIDArgsForCall []struct {
		arg1 string
	}
	getSpaceQuotasByOrgGUIDReturns struct {
		result1 []resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}
	getSpaceQuotasByOrgGUIDReturnsOnCall map[int]struct {
		result1 []resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceSummaryByNameAndOrganizationStub        func(string, string) (v7action.SpaceSummary, v7action.Warnings, error)
	getSpaceSummaryByNameAndOrganizationMutex       sync.RWMutex
	getSpaceSummaryByNameAndOrganizationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getSpaceSummaryByNameAndOrganizationReturns struct {
		result1 v7action.SpaceSummary
		result2 v7action.Warnings
		result3 error
	}
	getSpaceSummaryByNameAndOrganizationReturnsOnCall map[int]struct {
		result1 v7action.SpaceSummary
		result2 v7action.Warnings
		result3 error
	}
	GetSpaceUsersByRoleTypeStub        func(string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error)
	getSpaceUsersByRoleTypeMutex       sync.RWMutex
	getSpaceUsersByRoleTypeArgsForCall []struct {
		arg1 string
	}
	getSpaceUsersByRoleTypeReturns struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}
	getSpaceUsersByRoleTypeReturnsOnCall map[int]struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}
	GetStackByNameStub        func(string) (resources.Stack, v7action.Warnings, error)
	getStackByNameMutex       sync.RWMutex
	getStackByNameArgsForCall []struct {
		arg1 string
	}
	getStackByNameReturns struct {
		result1 resources.Stack
		result2 v7action.Warnings
		result3 error
	}
	getStackByNameReturnsOnCall map[int]struct {
		result1 resources.Stack
		result2 v7action.Warnings
		result3 error
	}
	GetStackLabelsStub        func(string) (map[string]types.NullString, v7action.Warnings, error)
	getStackLabelsMutex       sync.RWMutex
	getStackLabelsArgsForCall []struct {
		arg1 string
	}
	getStackLabelsReturns struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	getStackLabelsReturnsOnCall map[int]struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}
	GetStacksStub        func(string) ([]resources.Stack, v7action.Warnings, error)
	getStacksMutex       sync.RWMutex
	getStacksArgsForCall []struct {
		arg1 string
	}
	getStacksReturns struct {
		result1 []resources.Stack
		result2 v7action.Warnings
		result3 error
	}
	getStacksReturnsOnCall map[int]struct {
		result1 []resources.Stack
		result2 v7action.Warnings
		result3 error
	}
	GetStreamingLogsForApplicationByNameAndSpaceStub        func(string, string, sharedaction.LogCacheClient) (<-chan sharedaction.LogMessage, <-chan error, context.CancelFunc, v7action.Warnings, error)
	getStreamingLogsForApplicationByNameAndSpaceMutex       sync.RWMutex
	getStreamingLogsForApplicationByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 sharedaction.LogCacheClient
	}
	getStreamingLogsForApplicationByNameAndSpaceReturns struct {
		result1 <-chan sharedaction.LogMessage
		result2 <-chan error
		result3 context.CancelFunc
		result4 v7action.Warnings
		result5 error
	}
	getStreamingLogsForApplicationByNameAndSpaceReturnsOnCall map[int]struct {
		result1 <-chan sharedaction.LogMessage
		result2 <-chan error
		result3 context.CancelFunc
		result4 v7action.Warnings
		result5 error
	}
	GetTaskBySequenceIDAndApplicationStub        func(int, string) (resources.Task, v7action.Warnings, error)
	getTaskBySequenceIDAndApplicationMutex       sync.RWMutex
	getTaskBySequenceIDAndApplicationArgsForCall []struct {
		arg1 int
		arg2 string
	}
	getTaskBySequenceIDAndApplicationReturns struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	getTaskBySequenceIDAndApplicationReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	GetUAAAPIVersionStub        func() (string, error)
	getUAAAPIVersionMutex       sync.RWMutex
	getUAAAPIVersionArgsForCall []struct {
	}
	getUAAAPIVersionReturns struct {
		result1 string
		result2 error
	}
	getUAAAPIVersionReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	GetUnstagedNewestPackageGUIDStub        func(string) (string, v7action.Warnings, error)
	getUnstagedNewestPackageGUIDMutex       sync.RWMutex
	getUnstagedNewestPackageGUIDArgsForCall []struct {
		arg1 string
	}
	getUnstagedNewestPackageGUIDReturns struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	getUnstagedNewestPackageGUIDReturnsOnCall map[int]struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	GetUserStub        func(string, string) (resources.User, error)
	getUserMutex       sync.RWMutex
	getUserArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getUserReturns struct {
		result1 resources.User
		result2 error
	}
	getUserReturnsOnCall map[int]struct {
		result1 resources.User
		result2 error
	}
	MakeCurlRequestStub        func(string, string, []string, string, bool) ([]byte, *http.Response, error)
	makeCurlRequestMutex       sync.RWMutex
	makeCurlRequestArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 []string
		arg4 string
		arg5 bool
	}
	makeCurlRequestReturns struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}
	makeCurlRequestReturnsOnCall map[int]struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}
	MapRouteStub        func(string, string, string) (v7action.Warnings, error)
	mapRouteMutex       sync.RWMutex
	mapRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	mapRouteReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	mapRouteReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	MarketplaceStub        func(v7action.MarketplaceFilter) ([]v7action.ServiceOfferingWithPlans, v7action.Warnings, error)
	marketplaceMutex       sync.RWMutex
	marketplaceArgsForCall []struct {
		arg1 v7action.MarketplaceFilter
	}
	marketplaceReturns struct {
		result1 []v7action.ServiceOfferingWithPlans
		result2 v7action.Warnings
		result3 error
	}
	marketplaceReturnsOnCall map[int]struct {
		result1 []v7action.ServiceOfferingWithPlans
		result2 v7action.Warnings
		result3 error
	}
	MoveRouteStub        func(string, string) (v7action.Warnings, error)
	moveRouteMutex       sync.RWMutex
	moveRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	moveRouteReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	moveRouteReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	ParseAccessTokenStub        func(string) (jwt.JWT, error)
	parseAccessTokenMutex       sync.RWMutex
	parseAccessTokenArgsForCall []struct {
		arg1 string
	}
	parseAccessTokenReturns struct {
		result1 jwt.JWT
		result2 error
	}
	parseAccessTokenReturnsOnCall map[int]struct {
		result1 jwt.JWT
		result2 error
	}
	PollBuildStub        func(string, string) (resources.Droplet, v7action.Warnings, error)
	pollBuildMutex       sync.RWMutex
	pollBuildArgsForCall []struct {
		arg1 string
		arg2 string
	}
	pollBuildReturns struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}
	pollBuildReturnsOnCall map[int]struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}
	PollPackageStub        func(resources.Package) (resources.Package, v7action.Warnings, error)
	pollPackageMutex       sync.RWMutex
	pollPackageArgsForCall []struct {
		arg1 resources.Package
	}
	pollPackageReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	pollPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	PollStartStub        func(resources.Application, bool, func(string)) (v7action.Warnings, error)
	pollStartMutex       sync.RWMutex
	pollStartArgsForCall []struct {
		arg1 resources.Application
		arg2 bool
		arg3 func(string)
	}
	pollStartReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	pollStartReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	PollStartForRollingStub        func(resources.Application, string, bool, func(string)) (v7action.Warnings, error)
	pollStartForRollingMutex       sync.RWMutex
	pollStartForRollingArgsForCall []struct {
		arg1 resources.Application
		arg2 string
		arg3 bool
		arg4 func(string)
	}
	pollStartForRollingReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	pollStartForRollingReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	PollTaskStub        func(resources.Task) (resources.Task, v7action.Warnings, error)
	pollTaskMutex       sync.RWMutex
	pollTaskArgsForCall []struct {
		arg1 resources.Task
	}
	pollTaskReturns struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	pollTaskReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	PollUploadBuildpackJobStub        func(ccv3.JobURL) (v7action.Warnings, error)
	pollUploadBuildpackJobMutex       sync.RWMutex
	pollUploadBuildpackJobArgsForCall []struct {
		arg1 ccv3.JobURL
	}
	pollUploadBuildpackJobReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	pollUploadBuildpackJobReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	PrepareBuildpackBitsStub        func(string, string, v7action.Downloader) (string, error)
	prepareBuildpackBitsMutex       sync.RWMutex
	prepareBuildpackBitsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 v7action.Downloader
	}
	prepareBuildpackBitsReturns struct {
		result1 string
		result2 error
	}
	prepareBuildpackBitsReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	PurgeServiceInstanceStub        func(string, string) (v7action.Warnings, error)
	purgeServiceInstanceMutex       sync.RWMutex
	purgeServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	purgeServiceInstanceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	purgeServiceInstanceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	PurgeServiceOfferingByNameAndBrokerStub        func(string, string) (v7action.Warnings, error)
	purgeServiceOfferingByNameAndBrokerMutex       sync.RWMutex
	purgeServiceOfferingByNameAndBrokerArgsForCall []struct {
		arg1 string
		arg2 string
	}
	purgeServiceOfferingByNameAndBrokerReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	purgeServiceOfferingByNameAndBrokerReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	RefreshAccessTokenStub        func() (string, error)
	refreshAccessTokenMutex       sync.RWMutex
	refreshAccessTokenArgsForCall []struct {
	}
	refreshAccessTokenReturns struct {
		result1 string
		result2 error
	}
	refreshAccessTokenReturnsOnCall map[int]struct {
		result1 string
		result2 error
	}
	RenameApplicationByNameAndSpaceGUIDStub        func(string, string, string) (resources.Application, v7action.Warnings, error)
	renameApplicationByNameAndSpaceGUIDMutex       sync.RWMutex
	renameApplicationByNameAndSpaceGUIDArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	renameApplicationByNameAndSpaceGUIDReturns struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	renameApplicationByNameAndSpaceGUIDReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	RenameOrganizationStub        func(string, string) (resources.Organization, v7action.Warnings, error)
	renameOrganizationMutex       sync.RWMutex
	renameOrganizationArgsForCall []struct {
		arg1 string
		arg2 string
	}
	renameOrganizationReturns struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	renameOrganizationReturnsOnCall map[int]struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}
	RenameServiceInstanceStub        func(string, string, string) (v7action.Warnings, error)
	renameServiceInstanceMutex       sync.RWMutex
	renameServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	renameServiceInstanceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	renameServiceInstanceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	RenameSpaceByNameAndOrganizationGUIDStub        func(string, string, string) (resources.Space, v7action.Warnings, error)
	renameSpaceByNameAndOrganizationGUIDMutex       sync.RWMutex
	renameSpaceByNameAndOrganizationGUIDArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	renameSpaceByNameAndOrganizationGUIDReturns struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}
	renameSpaceByNameAndOrganizationGUIDReturnsOnCall map[int]struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}
	ResetOrganizationDefaultIsolationSegmentStub        func(string) (v7action.Warnings, error)
	resetOrganizationDefaultIsolationSegmentMutex       sync.RWMutex
	resetOrganizationDefaultIsolationSegmentArgsForCall []struct {
		arg1 string
	}
	resetOrganizationDefaultIsolationSegmentReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	resetOrganizationDefaultIsolationSegmentReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	ResetSpaceIsolationSegmentStub        func(string, string) (string, v7action.Warnings, error)
	resetSpaceIsolationSegmentMutex       sync.RWMutex
	resetSpaceIsolationSegmentArgsForCall []struct {
		arg1 string
		arg2 string
	}
	resetSpaceIsolationSegmentReturns struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	resetSpaceIsolationSegmentReturnsOnCall map[int]struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	ResourceMatchStub        func([]sharedaction.V3Resource) ([]sharedaction.V3Resource, v7action.Warnings, error)
	resourceMatchMutex       sync.RWMutex
	resourceMatchArgsForCall []struct {
		arg1 []sharedaction.V3Resource
	}
	resourceMatchReturns struct {
		result1 []sharedaction.V3Resource
		result2 v7action.Warnings
		result3 error
	}
	resourceMatchReturnsOnCall map[int]struct {
		result1 []sharedaction.V3Resource
		result2 v7action.Warnings
		result3 error
	}
	RestartApplicationStub        func(string, bool) (v7action.Warnings, error)
	restartApplicationMutex       sync.RWMutex
	restartApplicationArgsForCall []struct {
		arg1 string
		arg2 bool
	}
	restartApplicationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	restartApplicationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	RevokeAccessAndRefreshTokensStub        func() error
	revokeAccessAndRefreshTokensMutex       sync.RWMutex
	revokeAccessAndRefreshTokensArgsForCall []struct {
	}
	revokeAccessAndRefreshTokensReturns struct {
		result1 error
	}
	revokeAccessAndRefreshTokensReturnsOnCall map[int]struct {
		result1 error
	}
	RunTaskStub        func(string, resources.Task) (resources.Task, v7action.Warnings, error)
	runTaskMutex       sync.RWMutex
	runTaskArgsForCall []struct {
		arg1 string
		arg2 resources.Task
	}
	runTaskReturns struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	runTaskReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	ScaleProcessByApplicationStub        func(string, resources.Process) (v7action.Warnings, error)
	scaleProcessByApplicationMutex       sync.RWMutex
	scaleProcessByApplicationArgsForCall []struct {
		arg1 string
		arg2 resources.Process
	}
	scaleProcessByApplicationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	scaleProcessByApplicationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	ScheduleTokenRefreshStub        func(func(time.Duration) <-chan time.Time, chan struct{}, chan struct{}) (<-chan error, error)
	scheduleTokenRefreshMutex       sync.RWMutex
	scheduleTokenRefreshArgsForCall []struct {
		arg1 func(time.Duration) <-chan time.Time
		arg2 chan struct{}
		arg3 chan struct{}
	}
	scheduleTokenRefreshReturns struct {
		result1 <-chan error
		result2 error
	}
	scheduleTokenRefreshReturnsOnCall map[int]struct {
		result1 <-chan error
		result2 error
	}
	SetApplicationDropletStub        func(string, string) (v7action.Warnings, error)
	setApplicationDropletMutex       sync.RWMutex
	setApplicationDropletArgsForCall []struct {
		arg1 string
		arg2 string
	}
	setApplicationDropletReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setApplicationDropletReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetApplicationDropletByApplicationNameAndSpaceStub        func(string, string, string) (v7action.Warnings, error)
	setApplicationDropletByApplicationNameAndSpaceMutex       sync.RWMutex
	setApplicationDropletByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	setApplicationDropletByApplicationNameAndSpaceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setApplicationDropletByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetApplicationManifestStub        func(string, []byte) (v7action.Warnings, error)
	setApplicationManifestMutex       sync.RWMutex
	setApplicationManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	setApplicationManifestReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setApplicationManifestReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetApplicationProcessHealthCheckTypeByNameAndSpaceStub        func(string, string, constanta.HealthCheckType, string, string, int64) (resources.Application, v7action.Warnings, error)
	setApplicationProcessHealthCheckTypeByNameAndSpaceMutex       sync.RWMutex
	setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 constanta.HealthCheckType
		arg4 string
		arg5 string
		arg6 int64
	}
	setApplicationProcessHealthCheckTypeByNameAndSpaceReturns struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	setApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	SetEnvironmentVariableByApplicationNameAndSpaceStub        func(string, string, v7action.EnvironmentVariablePair) (v7action.Warnings, error)
	setEnvironmentVariableByApplicationNameAndSpaceMutex       sync.RWMutex
	setEnvironmentVariableByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 v7action.EnvironmentVariablePair
	}
	setEnvironmentVariableByApplicationNameAndSpaceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetEnvironmentVariableGroupStub        func(constanta.EnvironmentVariableGroupName, resources.EnvironmentVariables) (v7action.Warnings, error)
	setEnvironmentVariableGroupMutex       sync.RWMutex
	setEnvironmentVariableGroupArgsForCall []struct {
		arg1 constanta.EnvironmentVariableGroupName
		arg2 resources.EnvironmentVariables
	}
	setEnvironmentVariableGroupReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setEnvironmentVariableGroupReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetOrganizationDefaultIsolationSegmentStub        func(string, string) (v7action.Warnings, error)
	setOrganizationDefaultIsolationSegmentMutex       sync.RWMutex
	setOrganizationDefaultIsolationSegmentArgsForCall []struct {
		arg1 string
		arg2 string
	}
	setOrganizationDefaultIsolationSegmentReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setOrganizationDefaultIsolationSegmentReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetSpaceManifestStub        func(string, []byte) (v7action.Warnings, error)
	setSpaceManifestMutex       sync.RWMutex
	setSpaceManifestArgsForCall []struct {
		arg1 string
		arg2 []byte
	}
	setSpaceManifestReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setSpaceManifestReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SetTargetStub        func(v7action.TargetSettings) (v7action.Warnings, error)
	setTargetMutex       sync.RWMutex
	setTargetArgsForCall []struct {
		arg1 v7action.TargetSettings
	}
	setTargetReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	setTargetReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	SharePrivateDomainStub        func(string, string) (v7action.Warnings, error)
	sharePrivateDomainMutex       sync.RWMutex
	sharePrivateDomainArgsForCall []struct {
		arg1 string
		arg2 string
	}
	sharePrivateDomainReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	sharePrivateDomainReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	ShareRouteStub        func(string, string) (v7action.Warnings, error)
	shareRouteMutex       sync.RWMutex
	shareRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	shareRouteReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	shareRouteReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	ShareServiceInstanceToSpaceAndOrgStub        func(string, string, string, v7action.ServiceInstanceSharingParams) (v7action.Warnings, error)
	shareServiceInstanceToSpaceAndOrgMutex       sync.RWMutex
	shareServiceInstanceToSpaceAndOrgArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 v7action.ServiceInstanceSharingParams
	}
	shareServiceInstanceToSpaceAndOrgReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	shareServiceInstanceToSpaceAndOrgReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	StageApplicationPackageStub        func(string) (resources.Build, v7action.Warnings, error)
	stageApplicationPackageMutex       sync.RWMutex
	stageApplicationPackageArgsForCall []struct {
		arg1 string
	}
	stageApplicationPackageReturns struct {
		result1 resources.Build
		result2 v7action.Warnings
		result3 error
	}
	stageApplicationPackageReturnsOnCall map[int]struct {
		result1 resources.Build
		result2 v7action.Warnings
		result3 error
	}
	StagePackageStub        func(string, string, string) (<-chan resources.Droplet, <-chan v7action.Warnings, <-chan error)
	stagePackageMutex       sync.RWMutex
	stagePackageArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	stagePackageReturns struct {
		result1 <-chan resources.Droplet
		result2 <-chan v7action.Warnings
		result3 <-chan error
	}
	stagePackageReturnsOnCall map[int]struct {
		result1 <-chan resources.Droplet
		result2 <-chan v7action.Warnings
		result3 <-chan error
	}
	StartApplicationStub        func(string) (v7action.Warnings, error)
	startApplicationMutex       sync.RWMutex
	startApplicationArgsForCall []struct {
		arg1 string
	}
	startApplicationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	startApplicationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	StopApplicationStub        func(string) (v7action.Warnings, error)
	stopApplicationMutex       sync.RWMutex
	stopApplicationArgsForCall []struct {
		arg1 string
	}
	stopApplicationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	stopApplicationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	TerminateTaskStub        func(string) (resources.Task, v7action.Warnings, error)
	terminateTaskMutex       sync.RWMutex
	terminateTaskArgsForCall []struct {
		arg1 string
	}
	terminateTaskReturns struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	terminateTaskReturnsOnCall map[int]struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}
	UnbindSecurityGroupStub        func(string, string, string, constanta.SecurityGroupLifecycle) (v7action.Warnings, error)
	unbindSecurityGroupMutex       sync.RWMutex
	unbindSecurityGroupArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 constanta.SecurityGroupLifecycle
	}
	unbindSecurityGroupReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unbindSecurityGroupReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UnmapRouteStub        func(string, string) (v7action.Warnings, error)
	unmapRouteMutex       sync.RWMutex
	unmapRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unmapRouteReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unmapRouteReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UnsetEnvironmentVariableByApplicationNameAndSpaceStub        func(string, string, string) (v7action.Warnings, error)
	unsetEnvironmentVariableByApplicationNameAndSpaceMutex       sync.RWMutex
	unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	unsetEnvironmentVariableByApplicationNameAndSpaceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UnsetSpaceQuotaStub        func(string, string, string) (v7action.Warnings, error)
	unsetSpaceQuotaMutex       sync.RWMutex
	unsetSpaceQuotaArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	unsetSpaceQuotaReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unsetSpaceQuotaReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UnsharePrivateDomainStub        func(string, string) (v7action.Warnings, error)
	unsharePrivateDomainMutex       sync.RWMutex
	unsharePrivateDomainArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unsharePrivateDomainReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unsharePrivateDomainReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UnshareRouteStub        func(string, string) (v7action.Warnings, error)
	unshareRouteMutex       sync.RWMutex
	unshareRouteArgsForCall []struct {
		arg1 string
		arg2 string
	}
	unshareRouteReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unshareRouteReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UnshareServiceInstanceFromSpaceAndOrgStub        func(string, string, string, v7action.ServiceInstanceSharingParams) (v7action.Warnings, error)
	unshareServiceInstanceFromSpaceAndOrgMutex       sync.RWMutex
	unshareServiceInstanceFromSpaceAndOrgArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 v7action.ServiceInstanceSharingParams
	}
	unshareServiceInstanceFromSpaceAndOrgReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	unshareServiceInstanceFromSpaceAndOrgReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateAppFeatureStub        func(resources.Application, bool, string) (v7action.Warnings, error)
	updateAppFeatureMutex       sync.RWMutex
	updateAppFeatureArgsForCall []struct {
		arg1 resources.Application
		arg2 bool
		arg3 string
	}
	updateAppFeatureReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateAppFeatureReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateApplicationStub        func(resources.Application) (resources.Application, v7action.Warnings, error)
	updateApplicationMutex       sync.RWMutex
	updateApplicationArgsForCall []struct {
		arg1 resources.Application
	}
	updateApplicationReturns struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	updateApplicationReturnsOnCall map[int]struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}
	UpdateApplicationLabelsByApplicationNameStub        func(string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateApplicationLabelsByApplicationNameMutex       sync.RWMutex
	updateApplicationLabelsByApplicationNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}
	updateApplicationLabelsByApplicationNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateApplicationLabelsByApplicationNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateBuildpackByNameAndStackStub        func(string, string, resources.Buildpack) (resources.Buildpack, v7action.Warnings, error)
	updateBuildpackByNameAndStackMutex       sync.RWMutex
	updateBuildpackByNameAndStackArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 resources.Buildpack
	}
	updateBuildpackByNameAndStackReturns struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	updateBuildpackByNameAndStackReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	UpdateBuildpackLabelsByBuildpackNameAndStackStub        func(string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateBuildpackLabelsByBuildpackNameAndStackMutex       sync.RWMutex
	updateBuildpackLabelsByBuildpackNameAndStackArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}
	updateBuildpackLabelsByBuildpackNameAndStackReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateBuildpackLabelsByBuildpackNameAndStackReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateDestinationStub        func(string, string, string) (v7action.Warnings, error)
	updateDestinationMutex       sync.RWMutex
	updateDestinationArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	updateDestinationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateDestinationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateDomainLabelsByDomainNameStub        func(string, map[string]types.NullString) (v7action.Warnings, error)
	updateDomainLabelsByDomainNameMutex       sync.RWMutex
	updateDomainLabelsByDomainNameArgsForCall []struct {
		arg1 string
		arg2 map[string]types.NullString
	}
	updateDomainLabelsByDomainNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateDomainLabelsByDomainNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateManagedServiceInstanceStub        func(v7action.UpdateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error)
	updateManagedServiceInstanceMutex       sync.RWMutex
	updateManagedServiceInstanceArgsForCall []struct {
		arg1 v7action.UpdateManagedServiceInstanceParams
	}
	updateManagedServiceInstanceReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	updateManagedServiceInstanceReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	UpdateOrganizationLabelsByOrganizationNameStub        func(string, map[string]types.NullString) (v7action.Warnings, error)
	updateOrganizationLabelsByOrganizationNameMutex       sync.RWMutex
	updateOrganizationLabelsByOrganizationNameArgsForCall []struct {
		arg1 string
		arg2 map[string]types.NullString
	}
	updateOrganizationLabelsByOrganizationNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateOrganizationLabelsByOrganizationNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateOrganizationQuotaStub        func(string, string, v7action.QuotaLimits) (v7action.Warnings, error)
	updateOrganizationQuotaMutex       sync.RWMutex
	updateOrganizationQuotaArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 v7action.QuotaLimits
	}
	updateOrganizationQuotaReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateOrganizationQuotaReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateProcessByTypeAndApplicationStub        func(string, string, resources.Process) (v7action.Warnings, error)
	updateProcessByTypeAndApplicationMutex       sync.RWMutex
	updateProcessByTypeAndApplicationArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 resources.Process
	}
	updateProcessByTypeAndApplicationReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateProcessByTypeAndApplicationReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateRouteLabelsStub        func(string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateRouteLabelsMutex       sync.RWMutex
	updateRouteLabelsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}
	updateRouteLabelsReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateRouteLabelsReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateSecurityGroupStub        func(string, string) (v7action.Warnings, error)
	updateSecurityGroupMutex       sync.RWMutex
	updateSecurityGroupArgsForCall []struct {
		arg1 string
		arg2 string
	}
	updateSecurityGroupReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateSecurityGroupReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateSecurityGroupGloballyEnabledStub        func(string, constanta.SecurityGroupLifecycle, bool) (v7action.Warnings, error)
	updateSecurityGroupGloballyEnabledMutex       sync.RWMutex
	updateSecurityGroupGloballyEnabledArgsForCall []struct {
		arg1 string
		arg2 constanta.SecurityGroupLifecycle
		arg3 bool
	}
	updateSecurityGroupGloballyEnabledReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateSecurityGroupGloballyEnabledReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateServiceBrokerStub        func(string, resources.ServiceBroker) (v7action.Warnings, error)
	updateServiceBrokerMutex       sync.RWMutex
	updateServiceBrokerArgsForCall []struct {
		arg1 string
		arg2 resources.ServiceBroker
	}
	updateServiceBrokerReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateServiceBrokerReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateServiceBrokerLabelsByServiceBrokerNameStub        func(string, map[string]types.NullString) (v7action.Warnings, error)
	updateServiceBrokerLabelsByServiceBrokerNameMutex       sync.RWMutex
	updateServiceBrokerLabelsByServiceBrokerNameArgsForCall []struct {
		arg1 string
		arg2 map[string]types.NullString
	}
	updateServiceBrokerLabelsByServiceBrokerNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateServiceInstanceLabelsStub        func(string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateServiceInstanceLabelsMutex       sync.RWMutex
	updateServiceInstanceLabelsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}
	updateServiceInstanceLabelsReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateServiceInstanceLabelsReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateServiceOfferingLabelsStub        func(string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateServiceOfferingLabelsMutex       sync.RWMutex
	updateServiceOfferingLabelsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}
	updateServiceOfferingLabelsReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateServiceOfferingLabelsReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateServicePlanLabelsStub        func(string, string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateServicePlanLabelsMutex       sync.RWMutex
	updateServicePlanLabelsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 map[string]types.NullString
	}
	updateServicePlanLabelsReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateServicePlanLabelsReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateSpaceFeatureStub        func(string, string, bool, string) (v7action.Warnings, error)
	updateSpaceFeatureMutex       sync.RWMutex
	updateSpaceFeatureArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
		arg4 string
	}
	updateSpaceFeatureReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateSpaceFeatureReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateSpaceLabelsBySpaceNameStub        func(string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateSpaceLabelsBySpaceNameMutex       sync.RWMutex
	updateSpaceLabelsBySpaceNameArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}
	updateSpaceLabelsBySpaceNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateSpaceLabelsBySpaceNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateSpaceQuotaStub        func(string, string, string, v7action.QuotaLimits) (v7action.Warnings, error)
	updateSpaceQuotaMutex       sync.RWMutex
	updateSpaceQuotaArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 v7action.QuotaLimits
	}
	updateSpaceQuotaReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateSpaceQuotaReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateStackLabelsByStackNameStub        func(string, map[string]types.NullString) (v7action.Warnings, error)
	updateStackLabelsByStackNameMutex       sync.RWMutex
	updateStackLabelsByStackNameArgsForCall []struct {
		arg1 string
		arg2 map[string]types.NullString
	}
	updateStackLabelsByStackNameReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateStackLabelsByStackNameReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpdateUserPasswordStub        func(string, string, string) error
	updateUserPasswordMutex       sync.RWMutex
	updateUserPasswordArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	updateUserPasswordReturns struct {
		result1 error
	}
	updateUserPasswordReturnsOnCall map[int]struct {
		result1 error
	}
	UpdateUserProvidedServiceInstanceStub        func(string, string, resources.ServiceInstance) (v7action.Warnings, error)
	updateUserProvidedServiceInstanceMutex       sync.RWMutex
	updateUserProvidedServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 resources.ServiceInstance
	}
	updateUserProvidedServiceInstanceReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateUserProvidedServiceInstanceReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	UpgradeManagedServiceInstanceStub        func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error)
	upgradeManagedServiceInstanceMutex       sync.RWMutex
	upgradeManagedServiceInstanceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	upgradeManagedServiceInstanceReturns struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	upgradeManagedServiceInstanceReturnsOnCall map[int]struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}
	UploadBitsPackageStub        func(resources.Package, []sharedaction.V3Resource, io.Reader, int64) (resources.Package, v7action.Warnings, error)
	uploadBitsPackageMutex       sync.RWMutex
	uploadBitsPackageArgsForCall []struct {
		arg1 resources.Package
		arg2 []sharedaction.V3Resource
		arg3 io.Reader
		arg4 int64
	}
	uploadBitsPackageReturns struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	uploadBitsPackageReturnsOnCall map[int]struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}
	UploadBuildpackStub        func(string, string, v7action.SimpleProgressBar) (ccv3.JobURL, v7action.Warnings, error)
	uploadBuildpackMutex       sync.RWMutex
	uploadBuildpackArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 v7action.SimpleProgressBar
	}
	uploadBuildpackReturns struct {
		result1 ccv3.JobURL
		result2 v7action.Warnings
		result3 error
	}
	uploadBuildpackReturnsOnCall map[int]struct {
		result1 ccv3.JobURL
		result2 v7action.Warnings
		result3 error
	}
	UploadDropletStub        func(string, string, io.Reader, int64) (v7action.Warnings, error)
	uploadDropletMutex       sync.RWMutex
	uploadDropletArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 io.Reader
		arg4 int64
	}
	uploadDropletReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	uploadDropletReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeActor) ApplyOrganizationQuotaByName(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.applyOrganizationQuotaByNameMutex.Lock()
	ret, specificReturn := fake.applyOrganizationQuotaByNameReturnsOnCall[len(fake.applyOrganizationQuotaByNameArgsForCall)]
	fake.applyOrganizationQuotaByNameArgsForCall = append(fake.applyOrganizationQuotaByNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("ApplyOrganizationQuotaByName", []interface{}{arg1, arg2})
	fake.applyOrganizationQuotaByNameMutex.Unlock()
	if fake.ApplyOrganizationQuotaByNameStub != nil {
		return fake.ApplyOrganizationQuotaByNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.applyOrganizationQuotaByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ApplyOrganizationQuotaByNameCallCount() int {
	fake.applyOrganizationQuotaByNameMutex.RLock()
	defer fake.applyOrganizationQuotaByNameMutex.RUnlock()
	return len(fake.applyOrganizationQuotaByNameArgsForCall)
}

func (fake *FakeActor) ApplyOrganizationQuotaByNameCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.applyOrganizationQuotaByNameMutex.Lock()
	defer fake.applyOrganizationQuotaByNameMutex.Unlock()
	fake.ApplyOrganizationQuotaByNameStub = stub
}

func (fake *FakeActor) ApplyOrganizationQuotaByNameArgsForCall(i int) (string, string) {
	fake.applyOrganizationQuotaByNameMutex.RLock()
	defer fake.applyOrganizationQuotaByNameMutex.RUnlock()
	argsForCall := fake.applyOrganizationQuotaByNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) ApplyOrganizationQuotaByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.applyOrganizationQuotaByNameMutex.Lock()
	defer fake.applyOrganizationQuotaByNameMutex.Unlock()
	fake.ApplyOrganizationQuotaByNameStub = nil
	fake.applyOrganizationQuotaByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ApplyOrganizationQuotaByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.applyOrganizationQuotaByNameMutex.Lock()
	defer fake.applyOrganizationQuotaByNameMutex.Unlock()
	fake.ApplyOrganizationQuotaByNameStub = nil
	if fake.applyOrganizationQuotaByNameReturnsOnCall == nil {
		fake.applyOrganizationQuotaByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.applyOrganizationQuotaByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ApplySpaceQuotaByName(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.applySpaceQuotaByNameMutex.Lock()
	ret, specificReturn := fake.applySpaceQuotaByNameReturnsOnCall[len(fake.applySpaceQuotaByNameArgsForCall)]
	fake.applySpaceQuotaByNameArgsForCall = append(fake.applySpaceQuotaByNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("ApplySpaceQuotaByName", []interface{}{arg1, arg2, arg3})
	fake.applySpaceQuotaByNameMutex.Unlock()
	if fake.ApplySpaceQuotaByNameStub != nil {
		return fake.ApplySpaceQuotaByNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.applySpaceQuotaByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ApplySpaceQuotaByNameCallCount() int {
	fake.applySpaceQuotaByNameMutex.RLock()
	defer fake.applySpaceQuotaByNameMutex.RUnlock()
	return len(fake.applySpaceQuotaByNameArgsForCall)
}

func (fake *FakeActor) ApplySpaceQuotaByNameCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.applySpaceQuotaByNameMutex.Lock()
	defer fake.applySpaceQuotaByNameMutex.Unlock()
	fake.ApplySpaceQuotaByNameStub = stub
}

func (fake *FakeActor) ApplySpaceQuotaByNameArgsForCall(i int) (string, string, string) {
	fake.applySpaceQuotaByNameMutex.RLock()
	defer fake.applySpaceQuotaByNameMutex.RUnlock()
	argsForCall := fake.applySpaceQuotaByNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) ApplySpaceQuotaByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.applySpaceQuotaByNameMutex.Lock()
	defer fake.applySpaceQuotaByNameMutex.Unlock()
	fake.ApplySpaceQuotaByNameStub = nil
	fake.applySpaceQuotaByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ApplySpaceQuotaByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.applySpaceQuotaByNameMutex.Lock()
	defer fake.applySpaceQuotaByNameMutex.Unlock()
	fake.ApplySpaceQuotaByNameStub = nil
	if fake.applySpaceQuotaByNameReturnsOnCall == nil {
		fake.applySpaceQuotaByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.applySpaceQuotaByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpace(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.assignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall[len(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall)]
	fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall = append(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("AssignIsolationSegmentToSpaceByNameAndSpace", []interface{}{arg1, arg2})
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Unlock()
	if fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub != nil {
		return fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.assignIsolationSegmentToSpaceByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceCallCount() int {
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RLock()
	defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RUnlock()
	return len(fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Lock()
	defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Unlock()
	fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub = stub
}

func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceArgsForCall(i int) (string, string) {
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RLock()
	defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.assignIsolationSegmentToSpaceByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceReturns(result1 v7action.Warnings, result2 error) {
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Lock()
	defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Unlock()
	fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub = nil
	fake.assignIsolationSegmentToSpaceByNameAndSpaceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) AssignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Lock()
	defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Unlock()
	fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub = nil
	if fake.assignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall == nil {
		fake.assignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.assignIsolationSegmentToSpaceByNameAndSpaceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) Authenticate(arg1 map[string]string, arg2 string, arg3 constant.GrantType) error {
	fake.authenticateMutex.Lock()
	ret, specificReturn := fake.authenticateReturnsOnCall[len(fake.authenticateArgsForCall)]
	fake.authenticateArgsForCall = append(fake.authenticateArgsForCall, struct {
		arg1 map[string]string
		arg2 string
		arg3 constant.GrantType
	}{arg1, arg2, arg3})
	fake.recordInvocation("Authenticate", []interface{}{arg1, arg2, arg3})
	fake.authenticateMutex.Unlock()
	if fake.AuthenticateStub != nil {
		return fake.AuthenticateStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.authenticateReturns
	return fakeReturns.result1
}

func (fake *FakeActor) AuthenticateCallCount() int {
	fake.authenticateMutex.RLock()
	defer fake.authenticateMutex.RUnlock()
	return len(fake.authenticateArgsForCall)
}

func (fake *FakeActor) AuthenticateCalls(stub func(map[string]string, string, constant.GrantType) error) {
	fake.authenticateMutex.Lock()
	defer fake.authenticateMutex.Unlock()
	fake.AuthenticateStub = stub
}

func (fake *FakeActor) AuthenticateArgsForCall(i int) (map[string]string, string, constant.GrantType) {
	fake.authenticateMutex.RLock()
	defer fake.authenticateMutex.RUnlock()
	argsForCall := fake.authenticateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) AuthenticateReturns(result1 error) {
	fake.authenticateMutex.Lock()
	defer fake.authenticateMutex.Unlock()
	fake.AuthenticateStub = nil
	fake.authenticateReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeActor) AuthenticateReturnsOnCall(i int, result1 error) {
	fake.authenticateMutex.Lock()
	defer fake.authenticateMutex.Unlock()
	fake.AuthenticateStub = nil
	if fake.authenticateReturnsOnCall == nil {
		fake.authenticateReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.authenticateReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeActor) BindSecurityGroupToSpaces(arg1 string, arg2 []resources.Space, arg3 constanta.SecurityGroupLifecycle) (v7action.Warnings, error) {
	var arg2Copy []resources.Space
	if arg2 != nil {
		arg2Copy = make([]resources.Space, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.bindSecurityGroupToSpacesMutex.Lock()
	ret, specificReturn := fake.bindSecurityGroupToSpacesReturnsOnCall[len(fake.bindSecurityGroupToSpacesArgsForCall)]
	fake.bindSecurityGroupToSpacesArgsForCall = append(fake.bindSecurityGroupToSpacesArgsForCall, struct {
		arg1 string
		arg2 []resources.Space
		arg3 constanta.SecurityGroupLifecycle
	}{arg1, arg2Copy, arg3})
	fake.recordInvocation("BindSecurityGroupToSpaces", []interface{}{arg1, arg2Copy, arg3})
	fake.bindSecurityGroupToSpacesMutex.Unlock()
	if fake.BindSecurityGroupToSpacesStub != nil {
		return fake.BindSecurityGroupToSpacesStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.bindSecurityGroupToSpacesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) BindSecurityGroupToSpacesCallCount() int {
	fake.bindSecurityGroupToSpacesMutex.RLock()
	defer fake.bindSecurityGroupToSpacesMutex.RUnlock()
	return len(fake.bindSecurityGroupToSpacesArgsForCall)
}

func (fake *FakeActor) BindSecurityGroupToSpacesCalls(stub func(string, []resources.Space, constanta.SecurityGroupLifecycle) (v7action.Warnings, error)) {
	fake.bindSecurityGroupToSpacesMutex.Lock()
	defer fake.bindSecurityGroupToSpacesMutex.Unlock()
	fake.BindSecurityGroupToSpacesStub = stub
}

func (fake *FakeActor) BindSecurityGroupToSpacesArgsForCall(i int) (string, []resources.Space, constanta.SecurityGroupLifecycle) {
	fake.bindSecurityGroupToSpacesMutex.RLock()
	defer fake.bindSecurityGroupToSpacesMutex.RUnlock()
	argsForCall := fake.bindSecurityGroupToSpacesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) BindSecurityGroupToSpacesReturns(result1 v7action.Warnings, result2 error) {
	fake.bindSecurityGroupToSpacesMutex.Lock()
	defer fake.bindSecurityGroupToSpacesMutex.Unlock()
	fake.BindSecurityGroupToSpacesStub = nil
	fake.bindSecurityGroupToSpacesReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) BindSecurityGroupToSpacesReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.bindSecurityGroupToSpacesMutex.Lock()
	defer fake.bindSecurityGroupToSpacesMutex.Unlock()
	fake.BindSecurityGroupToSpacesStub = nil
	if fake.bindSecurityGroupToSpacesReturnsOnCall == nil {
		fake.bindSecurityGroupToSpacesReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.bindSecurityGroupToSpacesReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CancelDeployment(arg1 string) (v7action.Warnings, error) {
	fake.cancelDeploymentMutex.Lock()
	ret, specificReturn := fake.cancelDeploymentReturnsOnCall[len(fake.cancelDeploymentArgsForCall)]
	fake.cancelDeploymentArgsForCall = append(fake.cancelDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("CancelDeployment", []interface{}{arg1})
	fake.cancelDeploymentMutex.Unlock()
	if fake.CancelDeploymentStub != nil {
		return fake.CancelDeploymentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.cancelDeploymentReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CancelDeploymentCallCount() int {
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	return len(fake.cancelDeploymentArgsForCall)
}

func (fake *FakeActor) CancelDeploymentCalls(stub func(string) (v7action.Warnings, error)) {
	fake.cancelDeploymentMutex.Lock()
	defer fake.cancelDeploymentMutex.Unlock()
	fake.CancelDeploymentStub = stub
}

func (fake *FakeActor) CancelDeploymentArgsForCall(i int) string {
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	argsForCall := fake.cancelDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CancelDeploymentReturns(result1 v7action.Warnings, result2 error) {
	fake.cancelDeploymentMutex.Lock()
	defer fake.cancelDeploymentMutex.Unlock()
	fake.CancelDeploymentStub = nil
	fake.cancelDeploymentReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CancelDeploymentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.cancelDeploymentMutex.Lock()
	defer fake.cancelDeploymentMutex.Unlock()
	fake.CancelDeploymentStub = nil
	if fake.cancelDeploymentReturnsOnCall == nil {
		fake.cancelDeploymentReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.cancelDeploymentReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CheckRoute(arg1 string, arg2 string, arg3 string, arg4 int) (bool, v7action.Warnings, error) {
	fake.checkRouteMutex.Lock()
	ret, specificReturn := fake.checkRouteReturnsOnCall[len(fake.checkRouteArgsForCall)]
	fake.checkRouteArgsForCall = append(fake.checkRouteArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("CheckRoute", []interface{}{arg1, arg2, arg3, arg4})
	fake.checkRouteMutex.Unlock()
	if fake.CheckRouteStub != nil {
		return fake.CheckRouteStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.checkRouteReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeActor) CheckRouteCalls(stub func(string, string, string, int) (bool, v7action.Warnings, error)) {
	fake.checkRouteMutex.Lock()
	defer fake.checkRouteMutex.Unlock()
	fake.CheckRouteStub = stub
}

func (fake *FakeActor) CheckRouteArgsForCall(i int) (string, string, string, int) {
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	argsForCall := fake.checkRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

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

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

func (fake *FakeActor) ClearTarget() {
	fake.clearTargetMutex.Lock()
	fake.clearTargetArgsForCall = append(fake.clearTargetArgsForCall, struct {
	}{})
	fake.recordInvocation("ClearTarget", []interface{}{})
	fake.clearTargetMutex.Unlock()
	if fake.ClearTargetStub != nil {
		fake.ClearTargetStub()
	}
}

func (fake *FakeActor) ClearTargetCallCount() int {
	fake.clearTargetMutex.RLock()
	defer fake.clearTargetMutex.RUnlock()
	return len(fake.clearTargetArgsForCall)
}

func (fake *FakeActor) ClearTargetCalls(stub func()) {
	fake.clearTargetMutex.Lock()
	defer fake.clearTargetMutex.Unlock()
	fake.ClearTargetStub = stub
}

func (fake *FakeActor) CopyPackage(arg1 resources.Application, arg2 resources.Application) (resources.Package, v7action.Warnings, error) {
	fake.copyPackageMutex.Lock()
	ret, specificReturn := fake.copyPackageReturnsOnCall[len(fake.copyPackageArgsForCall)]
	fake.copyPackageArgsForCall = append(fake.copyPackageArgsForCall, struct {
		arg1 resources.Application
		arg2 resources.Application
	}{arg1, arg2})
	fake.recordInvocation("CopyPackage", []interface{}{arg1, arg2})
	fake.copyPackageMutex.Unlock()
	if fake.CopyPackageStub != nil {
		return fake.CopyPackageStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.copyPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CopyPackageCallCount() int {
	fake.copyPackageMutex.RLock()
	defer fake.copyPackageMutex.RUnlock()
	return len(fake.copyPackageArgsForCall)
}

func (fake *FakeActor) CopyPackageCalls(stub func(resources.Application, resources.Application) (resources.Package, v7action.Warnings, error)) {
	fake.copyPackageMutex.Lock()
	defer fake.copyPackageMutex.Unlock()
	fake.CopyPackageStub = stub
}

func (fake *FakeActor) CopyPackageArgsForCall(i int) (resources.Application, resources.Application) {
	fake.copyPackageMutex.RLock()
	defer fake.copyPackageMutex.RUnlock()
	argsForCall := fake.copyPackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CopyPackageReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.copyPackageMutex.Lock()
	defer fake.copyPackageMutex.Unlock()
	fake.CopyPackageStub = nil
	fake.copyPackageReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CopyPackageReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.copyPackageMutex.Lock()
	defer fake.copyPackageMutex.Unlock()
	fake.CopyPackageStub = nil
	if fake.copyPackageReturnsOnCall == nil {
		fake.copyPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.copyPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpace(arg1 string, arg2 string, arg3 string) (resources.Package, v7action.Warnings, error) {
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall[len(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall)]
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall = append(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateAndUploadBitsPackageByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Unlock()
	if fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub != nil {
		return fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceCallCount() int {
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RLock()
	defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceCalls(stub func(string, string, string) (resources.Package, v7action.Warnings, error)) {
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Lock()
	defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Unlock()
	fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall(i int) (string, string, string) {
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RLock()
	defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.createAndUploadBitsPackageByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Lock()
	defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Unlock()
	fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub = nil
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Lock()
	defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Unlock()
	fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub = nil
	if fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateApplicationDroplet(arg1 string) (resources.Droplet, v7action.Warnings, error) {
	fake.createApplicationDropletMutex.Lock()
	ret, specificReturn := fake.createApplicationDropletReturnsOnCall[len(fake.createApplicationDropletArgsForCall)]
	fake.createApplicationDropletArgsForCall = append(fake.createApplicationDropletArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("CreateApplicationDroplet", []interface{}{arg1})
	fake.createApplicationDropletMutex.Unlock()
	if fake.CreateApplicationDropletStub != nil {
		return fake.CreateApplicationDropletStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationDropletReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateApplicationDropletCallCount() int {
	fake.createApplicationDropletMutex.RLock()
	defer fake.createApplicationDropletMutex.RUnlock()
	return len(fake.createApplicationDropletArgsForCall)
}

func (fake *FakeActor) CreateApplicationDropletCalls(stub func(string) (resources.Droplet, v7action.Warnings, error)) {
	fake.createApplicationDropletMutex.Lock()
	defer fake.createApplicationDropletMutex.Unlock()
	fake.CreateApplicationDropletStub = stub
}

func (fake *FakeActor) CreateApplicationDropletArgsForCall(i int) string {
	fake.createApplicationDropletMutex.RLock()
	defer fake.createApplicationDropletMutex.RUnlock()
	argsForCall := fake.createApplicationDropletArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateApplicationDropletReturns(result1 resources.Droplet, result2 v7action.Warnings, result3 error) {
	fake.createApplicationDropletMutex.Lock()
	defer fake.createApplicationDropletMutex.Unlock()
	fake.CreateApplicationDropletStub = nil
	fake.createApplicationDropletReturns = struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateApplicationDropletReturnsOnCall(i int, result1 resources.Droplet, result2 v7action.Warnings, result3 error) {
	fake.createApplicationDropletMutex.Lock()
	defer fake.createApplicationDropletMutex.Unlock()
	fake.CreateApplicationDropletStub = nil
	if fake.createApplicationDropletReturnsOnCall == nil {
		fake.createApplicationDropletReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createApplicationDropletReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateApplicationInSpace(arg1 resources.Application, arg2 string) (resources.Application, v7action.Warnings, error) {
	fake.createApplicationInSpaceMutex.Lock()
	ret, specificReturn := fake.createApplicationInSpaceReturnsOnCall[len(fake.createApplicationInSpaceArgsForCall)]
	fake.createApplicationInSpaceArgsForCall = append(fake.createApplicationInSpaceArgsForCall, struct {
		arg1 resources.Application
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateApplicationInSpace", []interface{}{arg1, arg2})
	fake.createApplicationInSpaceMutex.Unlock()
	if fake.CreateApplicationInSpaceStub != nil {
		return fake.CreateApplicationInSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createApplicationInSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateApplicationInSpaceCallCount() int {
	fake.createApplicationInSpaceMutex.RLock()
	defer fake.createApplicationInSpaceMutex.RUnlock()
	return len(fake.createApplicationInSpaceArgsForCall)
}

func (fake *FakeActor) CreateApplicationInSpaceCalls(stub func(resources.Application, string) (resources.Application, v7action.Warnings, error)) {
	fake.createApplicationInSpaceMutex.Lock()
	defer fake.createApplicationInSpaceMutex.Unlock()
	fake.CreateApplicationInSpaceStub = stub
}

func (fake *FakeActor) CreateApplicationInSpaceArgsForCall(i int) (resources.Application, string) {
	fake.createApplicationInSpaceMutex.RLock()
	defer fake.createApplicationInSpaceMutex.RUnlock()
	argsForCall := fake.createApplicationInSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreateApplicationInSpaceReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.createApplicationInSpaceMutex.Lock()
	defer fake.createApplicationInSpaceMutex.Unlock()
	fake.CreateApplicationInSpaceStub = nil
	fake.createApplicationInSpaceReturns = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateApplicationInSpaceReturnsOnCall(i int, result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.createApplicationInSpaceMutex.Lock()
	defer fake.createApplicationInSpaceMutex.Unlock()
	fake.CreateApplicationInSpaceStub = nil
	if fake.createApplicationInSpaceReturnsOnCall == nil {
		fake.createApplicationInSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createApplicationInSpaceReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateBitsPackageByApplication(arg1 string) (resources.Package, v7action.Warnings, error) {
	fake.createBitsPackageByApplicationMutex.Lock()
	ret, specificReturn := fake.createBitsPackageByApplicationReturnsOnCall[len(fake.createBitsPackageByApplicationArgsForCall)]
	fake.createBitsPackageByApplicationArgsForCall = append(fake.createBitsPackageByApplicationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("CreateBitsPackageByApplication", []interface{}{arg1})
	fake.createBitsPackageByApplicationMutex.Unlock()
	if fake.CreateBitsPackageByApplicationStub != nil {
		return fake.CreateBitsPackageByApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createBitsPackageByApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateBitsPackageByApplicationCallCount() int {
	fake.createBitsPackageByApplicationMutex.RLock()
	defer fake.createBitsPackageByApplicationMutex.RUnlock()
	return len(fake.createBitsPackageByApplicationArgsForCall)
}

func (fake *FakeActor) CreateBitsPackageByApplicationCalls(stub func(string) (resources.Package, v7action.Warnings, error)) {
	fake.createBitsPackageByApplicationMutex.Lock()
	defer fake.createBitsPackageByApplicationMutex.Unlock()
	fake.CreateBitsPackageByApplicationStub = stub
}

func (fake *FakeActor) CreateBitsPackageByApplicationArgsForCall(i int) string {
	fake.createBitsPackageByApplicationMutex.RLock()
	defer fake.createBitsPackageByApplicationMutex.RUnlock()
	argsForCall := fake.createBitsPackageByApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateBitsPackageByApplicationReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createBitsPackageByApplicationMutex.Lock()
	defer fake.createBitsPackageByApplicationMutex.Unlock()
	fake.CreateBitsPackageByApplicationStub = nil
	fake.createBitsPackageByApplicationReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateBitsPackageByApplicationReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createBitsPackageByApplicationMutex.Lock()
	defer fake.createBitsPackageByApplicationMutex.Unlock()
	fake.CreateBitsPackageByApplicationStub = nil
	if fake.createBitsPackageByApplicationReturnsOnCall == nil {
		fake.createBitsPackageByApplicationReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createBitsPackageByApplicationReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateBuildpack(arg1 resources.Buildpack) (resources.Buildpack, v7action.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 *FakeActor) CreateBuildpackCallCount() int {
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	return len(fake.createBuildpackArgsForCall)
}

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

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

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

func (fake *FakeActor) CreateBuildpackReturnsOnCall(i int, result1 resources.Buildpack, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.createBuildpackReturnsOnCall[i] = struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDeploymentByApplicationAndDroplet(arg1 string, arg2 string) (string, v7action.Warnings, error) {
	fake.createDeploymentByApplicationAndDropletMutex.Lock()
	ret, specificReturn := fake.createDeploymentByApplicationAndDropletReturnsOnCall[len(fake.createDeploymentByApplicationAndDropletArgsForCall)]
	fake.createDeploymentByApplicationAndDropletArgsForCall = append(fake.createDeploymentByApplicationAndDropletArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateDeploymentByApplicationAndDroplet", []interface{}{arg1, arg2})
	fake.createDeploymentByApplicationAndDropletMutex.Unlock()
	if fake.CreateDeploymentByApplicationAndDropletStub != nil {
		return fake.CreateDeploymentByApplicationAndDropletStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createDeploymentByApplicationAndDropletReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateDeploymentByApplicationAndDropletCallCount() int {
	fake.createDeploymentByApplicationAndDropletMutex.RLock()
	defer fake.createDeploymentByApplicationAndDropletMutex.RUnlock()
	return len(fake.createDeploymentByApplicationAndDropletArgsForCall)
}

func (fake *FakeActor) CreateDeploymentByApplicationAndDropletCalls(stub func(string, string) (string, v7action.Warnings, error)) {
	fake.createDeploymentByApplicationAndDropletMutex.Lock()
	defer fake.createDeploymentByApplicationAndDropletMutex.Unlock()
	fake.CreateDeploymentByApplicationAndDropletStub = stub
}

func (fake *FakeActor) CreateDeploymentByApplicationAndDropletArgsForCall(i int) (string, string) {
	fake.createDeploymentByApplicationAndDropletMutex.RLock()
	defer fake.createDeploymentByApplicationAndDropletMutex.RUnlock()
	argsForCall := fake.createDeploymentByApplicationAndDropletArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreateDeploymentByApplicationAndDropletReturns(result1 string, result2 v7action.Warnings, result3 error) {
	fake.createDeploymentByApplicationAndDropletMutex.Lock()
	defer fake.createDeploymentByApplicationAndDropletMutex.Unlock()
	fake.CreateDeploymentByApplicationAndDropletStub = nil
	fake.createDeploymentByApplicationAndDropletReturns = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDeploymentByApplicationAndDropletReturnsOnCall(i int, result1 string, result2 v7action.Warnings, result3 error) {
	fake.createDeploymentByApplicationAndDropletMutex.Lock()
	defer fake.createDeploymentByApplicationAndDropletMutex.Unlock()
	fake.CreateDeploymentByApplicationAndDropletStub = nil
	if fake.createDeploymentByApplicationAndDropletReturnsOnCall == nil {
		fake.createDeploymentByApplicationAndDropletReturnsOnCall = make(map[int]struct {
			result1 string
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createDeploymentByApplicationAndDropletReturnsOnCall[i] = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDeploymentByApplicationAndRevision(arg1 string, arg2 string) (string, v7action.Warnings, error) {
	fake.createDeploymentByApplicationAndRevisionMutex.Lock()
	ret, specificReturn := fake.createDeploymentByApplicationAndRevisionReturnsOnCall[len(fake.createDeploymentByApplicationAndRevisionArgsForCall)]
	fake.createDeploymentByApplicationAndRevisionArgsForCall = append(fake.createDeploymentByApplicationAndRevisionArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateDeploymentByApplicationAndRevision", []interface{}{arg1, arg2})
	fake.createDeploymentByApplicationAndRevisionMutex.Unlock()
	if fake.CreateDeploymentByApplicationAndRevisionStub != nil {
		return fake.CreateDeploymentByApplicationAndRevisionStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createDeploymentByApplicationAndRevisionReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateDeploymentByApplicationAndRevisionCallCount() int {
	fake.createDeploymentByApplicationAndRevisionMutex.RLock()
	defer fake.createDeploymentByApplicationAndRevisionMutex.RUnlock()
	return len(fake.createDeploymentByApplicationAndRevisionArgsForCall)
}

func (fake *FakeActor) CreateDeploymentByApplicationAndRevisionCalls(stub func(string, string) (string, v7action.Warnings, error)) {
	fake.createDeploymentByApplicationAndRevisionMutex.Lock()
	defer fake.createDeploymentByApplicationAndRevisionMutex.Unlock()
	fake.CreateDeploymentByApplicationAndRevisionStub = stub
}

func (fake *FakeActor) CreateDeploymentByApplicationAndRevisionArgsForCall(i int) (string, string) {
	fake.createDeploymentByApplicationAndRevisionMutex.RLock()
	defer fake.createDeploymentByApplicationAndRevisionMutex.RUnlock()
	argsForCall := fake.createDeploymentByApplicationAndRevisionArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreateDeploymentByApplicationAndRevisionReturns(result1 string, result2 v7action.Warnings, result3 error) {
	fake.createDeploymentByApplicationAndRevisionMutex.Lock()
	defer fake.createDeploymentByApplicationAndRevisionMutex.Unlock()
	fake.CreateDeploymentByApplicationAndRevisionStub = nil
	fake.createDeploymentByApplicationAndRevisionReturns = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDeploymentByApplicationAndRevisionReturnsOnCall(i int, result1 string, result2 v7action.Warnings, result3 error) {
	fake.createDeploymentByApplicationAndRevisionMutex.Lock()
	defer fake.createDeploymentByApplicationAndRevisionMutex.Unlock()
	fake.CreateDeploymentByApplicationAndRevisionStub = nil
	if fake.createDeploymentByApplicationAndRevisionReturnsOnCall == nil {
		fake.createDeploymentByApplicationAndRevisionReturnsOnCall = make(map[int]struct {
			result1 string
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createDeploymentByApplicationAndRevisionReturnsOnCall[i] = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDockerPackageByApplication(arg1 string, arg2 v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) {
	fake.createDockerPackageByApplicationMutex.Lock()
	ret, specificReturn := fake.createDockerPackageByApplicationReturnsOnCall[len(fake.createDockerPackageByApplicationArgsForCall)]
	fake.createDockerPackageByApplicationArgsForCall = append(fake.createDockerPackageByApplicationArgsForCall, struct {
		arg1 string
		arg2 v7action.DockerImageCredentials
	}{arg1, arg2})
	fake.recordInvocation("CreateDockerPackageByApplication", []interface{}{arg1, arg2})
	fake.createDockerPackageByApplicationMutex.Unlock()
	if fake.CreateDockerPackageByApplicationStub != nil {
		return fake.CreateDockerPackageByApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createDockerPackageByApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateDockerPackageByApplicationCallCount() int {
	fake.createDockerPackageByApplicationMutex.RLock()
	defer fake.createDockerPackageByApplicationMutex.RUnlock()
	return len(fake.createDockerPackageByApplicationArgsForCall)
}

func (fake *FakeActor) CreateDockerPackageByApplicationCalls(stub func(string, v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error)) {
	fake.createDockerPackageByApplicationMutex.Lock()
	defer fake.createDockerPackageByApplicationMutex.Unlock()
	fake.CreateDockerPackageByApplicationStub = stub
}

func (fake *FakeActor) CreateDockerPackageByApplicationArgsForCall(i int) (string, v7action.DockerImageCredentials) {
	fake.createDockerPackageByApplicationMutex.RLock()
	defer fake.createDockerPackageByApplicationMutex.RUnlock()
	argsForCall := fake.createDockerPackageByApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreateDockerPackageByApplicationReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createDockerPackageByApplicationMutex.Lock()
	defer fake.createDockerPackageByApplicationMutex.Unlock()
	fake.CreateDockerPackageByApplicationStub = nil
	fake.createDockerPackageByApplicationReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDockerPackageByApplicationReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createDockerPackageByApplicationMutex.Lock()
	defer fake.createDockerPackageByApplicationMutex.Unlock()
	fake.CreateDockerPackageByApplicationStub = nil
	if fake.createDockerPackageByApplicationReturnsOnCall == nil {
		fake.createDockerPackageByApplicationReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createDockerPackageByApplicationReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpace(arg1 string, arg2 string, arg3 v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error) {
	fake.createDockerPackageByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.createDockerPackageByApplicationNameAndSpaceReturnsOnCall[len(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall)]
	fake.createDockerPackageByApplicationNameAndSpaceArgsForCall = append(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 v7action.DockerImageCredentials
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateDockerPackageByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.createDockerPackageByApplicationNameAndSpaceMutex.Unlock()
	if fake.CreateDockerPackageByApplicationNameAndSpaceStub != nil {
		return fake.CreateDockerPackageByApplicationNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createDockerPackageByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceCallCount() int {
	fake.createDockerPackageByApplicationNameAndSpaceMutex.RLock()
	defer fake.createDockerPackageByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.createDockerPackageByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceCalls(stub func(string, string, v7action.DockerImageCredentials) (resources.Package, v7action.Warnings, error)) {
	fake.createDockerPackageByApplicationNameAndSpaceMutex.Lock()
	defer fake.createDockerPackageByApplicationNameAndSpaceMutex.Unlock()
	fake.CreateDockerPackageByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceArgsForCall(i int) (string, string, v7action.DockerImageCredentials) {
	fake.createDockerPackageByApplicationNameAndSpaceMutex.RLock()
	defer fake.createDockerPackageByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.createDockerPackageByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createDockerPackageByApplicationNameAndSpaceMutex.Lock()
	defer fake.createDockerPackageByApplicationNameAndSpaceMutex.Unlock()
	fake.CreateDockerPackageByApplicationNameAndSpaceStub = nil
	fake.createDockerPackageByApplicationNameAndSpaceReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDockerPackageByApplicationNameAndSpaceReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.createDockerPackageByApplicationNameAndSpaceMutex.Lock()
	defer fake.createDockerPackageByApplicationNameAndSpaceMutex.Unlock()
	fake.CreateDockerPackageByApplicationNameAndSpaceStub = nil
	if fake.createDockerPackageByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.createDockerPackageByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createDockerPackageByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateIsolationSegmentByName(arg1 resources.IsolationSegment) (v7action.Warnings, error) {
	fake.createIsolationSegmentByNameMutex.Lock()
	ret, specificReturn := fake.createIsolationSegmentByNameReturnsOnCall[len(fake.createIsolationSegmentByNameArgsForCall)]
	fake.createIsolationSegmentByNameArgsForCall = append(fake.createIsolationSegmentByNameArgsForCall, struct {
		arg1 resources.IsolationSegment
	}{arg1})
	fake.recordInvocation("CreateIsolationSegmentByName", []interface{}{arg1})
	fake.createIsolationSegmentByNameMutex.Unlock()
	if fake.CreateIsolationSegmentByNameStub != nil {
		return fake.CreateIsolationSegmentByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createIsolationSegmentByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateIsolationSegmentByNameCallCount() int {
	fake.createIsolationSegmentByNameMutex.RLock()
	defer fake.createIsolationSegmentByNameMutex.RUnlock()
	return len(fake.createIsolationSegmentByNameArgsForCall)
}

func (fake *FakeActor) CreateIsolationSegmentByNameCalls(stub func(resources.IsolationSegment) (v7action.Warnings, error)) {
	fake.createIsolationSegmentByNameMutex.Lock()
	defer fake.createIsolationSegmentByNameMutex.Unlock()
	fake.CreateIsolationSegmentByNameStub = stub
}

func (fake *FakeActor) CreateIsolationSegmentByNameArgsForCall(i int) resources.IsolationSegment {
	fake.createIsolationSegmentByNameMutex.RLock()
	defer fake.createIsolationSegmentByNameMutex.RUnlock()
	argsForCall := fake.createIsolationSegmentByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateIsolationSegmentByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.createIsolationSegmentByNameMutex.Lock()
	defer fake.createIsolationSegmentByNameMutex.Unlock()
	fake.CreateIsolationSegmentByNameStub = nil
	fake.createIsolationSegmentByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateIsolationSegmentByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createIsolationSegmentByNameMutex.Lock()
	defer fake.createIsolationSegmentByNameMutex.Unlock()
	fake.CreateIsolationSegmentByNameStub = nil
	if fake.createIsolationSegmentByNameReturnsOnCall == nil {
		fake.createIsolationSegmentByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createIsolationSegmentByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateManagedServiceInstance(arg1 v7action.CreateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.createManagedServiceInstanceMutex.Lock()
	ret, specificReturn := fake.createManagedServiceInstanceReturnsOnCall[len(fake.createManagedServiceInstanceArgsForCall)]
	fake.createManagedServiceInstanceArgsForCall = append(fake.createManagedServiceInstanceArgsForCall, struct {
		arg1 v7action.CreateManagedServiceInstanceParams
	}{arg1})
	fake.recordInvocation("CreateManagedServiceInstance", []interface{}{arg1})
	fake.createManagedServiceInstanceMutex.Unlock()
	if fake.CreateManagedServiceInstanceStub != nil {
		return fake.CreateManagedServiceInstanceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createManagedServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateManagedServiceInstanceCallCount() int {
	fake.createManagedServiceInstanceMutex.RLock()
	defer fake.createManagedServiceInstanceMutex.RUnlock()
	return len(fake.createManagedServiceInstanceArgsForCall)
}

func (fake *FakeActor) CreateManagedServiceInstanceCalls(stub func(v7action.CreateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.createManagedServiceInstanceMutex.Lock()
	defer fake.createManagedServiceInstanceMutex.Unlock()
	fake.CreateManagedServiceInstanceStub = stub
}

func (fake *FakeActor) CreateManagedServiceInstanceArgsForCall(i int) v7action.CreateManagedServiceInstanceParams {
	fake.createManagedServiceInstanceMutex.RLock()
	defer fake.createManagedServiceInstanceMutex.RUnlock()
	argsForCall := fake.createManagedServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateManagedServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createManagedServiceInstanceMutex.Lock()
	defer fake.createManagedServiceInstanceMutex.Unlock()
	fake.CreateManagedServiceInstanceStub = nil
	fake.createManagedServiceInstanceReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateManagedServiceInstanceReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createManagedServiceInstanceMutex.Lock()
	defer fake.createManagedServiceInstanceMutex.Unlock()
	fake.CreateManagedServiceInstanceStub = nil
	if fake.createManagedServiceInstanceReturnsOnCall == nil {
		fake.createManagedServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createManagedServiceInstanceReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateOrgRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 bool) (v7action.Warnings, error) {
	fake.createOrgRoleMutex.Lock()
	ret, specificReturn := fake.createOrgRoleReturnsOnCall[len(fake.createOrgRoleArgsForCall)]
	fake.createOrgRoleArgsForCall = append(fake.createOrgRoleArgsForCall, struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 bool
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("CreateOrgRole", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.createOrgRoleMutex.Unlock()
	if fake.CreateOrgRoleStub != nil {
		return fake.CreateOrgRoleStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createOrgRoleReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateOrgRoleCallCount() int {
	fake.createOrgRoleMutex.RLock()
	defer fake.createOrgRoleMutex.RUnlock()
	return len(fake.createOrgRoleArgsForCall)
}

func (fake *FakeActor) CreateOrgRoleCalls(stub func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error)) {
	fake.createOrgRoleMutex.Lock()
	defer fake.createOrgRoleMutex.Unlock()
	fake.CreateOrgRoleStub = stub
}

func (fake *FakeActor) CreateOrgRoleArgsForCall(i int) (constanta.RoleType, string, string, string, bool) {
	fake.createOrgRoleMutex.RLock()
	defer fake.createOrgRoleMutex.RUnlock()
	argsForCall := fake.createOrgRoleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeActor) CreateOrgRoleReturns(result1 v7action.Warnings, result2 error) {
	fake.createOrgRoleMutex.Lock()
	defer fake.createOrgRoleMutex.Unlock()
	fake.CreateOrgRoleStub = nil
	fake.createOrgRoleReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateOrgRoleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createOrgRoleMutex.Lock()
	defer fake.createOrgRoleMutex.Unlock()
	fake.CreateOrgRoleStub = nil
	if fake.createOrgRoleReturnsOnCall == nil {
		fake.createOrgRoleReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createOrgRoleReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

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

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

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

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

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

func (fake *FakeActor) CreateOrganizationQuota(arg1 string, arg2 v7action.QuotaLimits) (v7action.Warnings, error) {
	fake.createOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.createOrganizationQuotaReturnsOnCall[len(fake.createOrganizationQuotaArgsForCall)]
	fake.createOrganizationQuotaArgsForCall = append(fake.createOrganizationQuotaArgsForCall, struct {
		arg1 string
		arg2 v7action.QuotaLimits
	}{arg1, arg2})
	fake.recordInvocation("CreateOrganizationQuota", []interface{}{arg1, arg2})
	fake.createOrganizationQuotaMutex.Unlock()
	if fake.CreateOrganizationQuotaStub != nil {
		return fake.CreateOrganizationQuotaStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createOrganizationQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateOrganizationQuotaCallCount() int {
	fake.createOrganizationQuotaMutex.RLock()
	defer fake.createOrganizationQuotaMutex.RUnlock()
	return len(fake.createOrganizationQuotaArgsForCall)
}

func (fake *FakeActor) CreateOrganizationQuotaCalls(stub func(string, v7action.QuotaLimits) (v7action.Warnings, error)) {
	fake.createOrganizationQuotaMutex.Lock()
	defer fake.createOrganizationQuotaMutex.Unlock()
	fake.CreateOrganizationQuotaStub = stub
}

func (fake *FakeActor) CreateOrganizationQuotaArgsForCall(i int) (string, v7action.QuotaLimits) {
	fake.createOrganizationQuotaMutex.RLock()
	defer fake.createOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.createOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreateOrganizationQuotaReturns(result1 v7action.Warnings, result2 error) {
	fake.createOrganizationQuotaMutex.Lock()
	defer fake.createOrganizationQuotaMutex.Unlock()
	fake.CreateOrganizationQuotaStub = nil
	fake.createOrganizationQuotaReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateOrganizationQuotaReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createOrganizationQuotaMutex.Lock()
	defer fake.createOrganizationQuotaMutex.Unlock()
	fake.CreateOrganizationQuotaStub = nil
	if fake.createOrganizationQuotaReturnsOnCall == nil {
		fake.createOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createOrganizationQuotaReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreatePrivateDomain(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.createPrivateDomainMutex.Lock()
	ret, specificReturn := fake.createPrivateDomainReturnsOnCall[len(fake.createPrivateDomainArgsForCall)]
	fake.createPrivateDomainArgsForCall = append(fake.createPrivateDomainArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreatePrivateDomain", []interface{}{arg1, arg2})
	fake.createPrivateDomainMutex.Unlock()
	if fake.CreatePrivateDomainStub != nil {
		return fake.CreatePrivateDomainStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createPrivateDomainReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreatePrivateDomainCallCount() int {
	fake.createPrivateDomainMutex.RLock()
	defer fake.createPrivateDomainMutex.RUnlock()
	return len(fake.createPrivateDomainArgsForCall)
}

func (fake *FakeActor) CreatePrivateDomainCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.createPrivateDomainMutex.Lock()
	defer fake.createPrivateDomainMutex.Unlock()
	fake.CreatePrivateDomainStub = stub
}

func (fake *FakeActor) CreatePrivateDomainArgsForCall(i int) (string, string) {
	fake.createPrivateDomainMutex.RLock()
	defer fake.createPrivateDomainMutex.RUnlock()
	argsForCall := fake.createPrivateDomainArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreatePrivateDomainReturns(result1 v7action.Warnings, result2 error) {
	fake.createPrivateDomainMutex.Lock()
	defer fake.createPrivateDomainMutex.Unlock()
	fake.CreatePrivateDomainStub = nil
	fake.createPrivateDomainReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreatePrivateDomainReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createPrivateDomainMutex.Lock()
	defer fake.createPrivateDomainMutex.Unlock()
	fake.CreatePrivateDomainStub = nil
	if fake.createPrivateDomainReturnsOnCall == nil {
		fake.createPrivateDomainReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createPrivateDomainReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateRoute(arg1 string, arg2 string, arg3 string, arg4 string, arg5 int) (resources.Route, v7action.Warnings, error) {
	fake.createRouteMutex.Lock()
	ret, specificReturn := fake.createRouteReturnsOnCall[len(fake.createRouteArgsForCall)]
	fake.createRouteArgsForCall = append(fake.createRouteArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 int
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("CreateRoute", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.createRouteMutex.Unlock()
	if fake.CreateRouteStub != nil {
		return fake.CreateRouteStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createRouteReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeActor) CreateRouteCalls(stub func(string, string, string, string, int) (resources.Route, v7action.Warnings, error)) {
	fake.createRouteMutex.Lock()
	defer fake.createRouteMutex.Unlock()
	fake.CreateRouteStub = stub
}

func (fake *FakeActor) CreateRouteArgsForCall(i int) (string, string, string, string, int) {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	argsForCall := fake.createRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

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

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

func (fake *FakeActor) CreateRouteBinding(arg1 v7action.CreateRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.createRouteBindingMutex.Lock()
	ret, specificReturn := fake.createRouteBindingReturnsOnCall[len(fake.createRouteBindingArgsForCall)]
	fake.createRouteBindingArgsForCall = append(fake.createRouteBindingArgsForCall, struct {
		arg1 v7action.CreateRouteBindingParams
	}{arg1})
	fake.recordInvocation("CreateRouteBinding", []interface{}{arg1})
	fake.createRouteBindingMutex.Unlock()
	if fake.CreateRouteBindingStub != nil {
		return fake.CreateRouteBindingStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createRouteBindingReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateRouteBindingCallCount() int {
	fake.createRouteBindingMutex.RLock()
	defer fake.createRouteBindingMutex.RUnlock()
	return len(fake.createRouteBindingArgsForCall)
}

func (fake *FakeActor) CreateRouteBindingCalls(stub func(v7action.CreateRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.createRouteBindingMutex.Lock()
	defer fake.createRouteBindingMutex.Unlock()
	fake.CreateRouteBindingStub = stub
}

func (fake *FakeActor) CreateRouteBindingArgsForCall(i int) v7action.CreateRouteBindingParams {
	fake.createRouteBindingMutex.RLock()
	defer fake.createRouteBindingMutex.RUnlock()
	argsForCall := fake.createRouteBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateRouteBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createRouteBindingMutex.Lock()
	defer fake.createRouteBindingMutex.Unlock()
	fake.CreateRouteBindingStub = nil
	fake.createRouteBindingReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateRouteBindingReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createRouteBindingMutex.Lock()
	defer fake.createRouteBindingMutex.Unlock()
	fake.CreateRouteBindingStub = nil
	if fake.createRouteBindingReturnsOnCall == nil {
		fake.createRouteBindingReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createRouteBindingReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateSecurityGroup(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.createSecurityGroupMutex.Lock()
	ret, specificReturn := fake.createSecurityGroupReturnsOnCall[len(fake.createSecurityGroupArgsForCall)]
	fake.createSecurityGroupArgsForCall = append(fake.createSecurityGroupArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("CreateSecurityGroup", []interface{}{arg1, arg2})
	fake.createSecurityGroupMutex.Unlock()
	if fake.CreateSecurityGroupStub != nil {
		return fake.CreateSecurityGroupStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createSecurityGroupReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateSecurityGroupCallCount() int {
	fake.createSecurityGroupMutex.RLock()
	defer fake.createSecurityGroupMutex.RUnlock()
	return len(fake.createSecurityGroupArgsForCall)
}

func (fake *FakeActor) CreateSecurityGroupCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.createSecurityGroupMutex.Lock()
	defer fake.createSecurityGroupMutex.Unlock()
	fake.CreateSecurityGroupStub = stub
}

func (fake *FakeActor) CreateSecurityGroupArgsForCall(i int) (string, string) {
	fake.createSecurityGroupMutex.RLock()
	defer fake.createSecurityGroupMutex.RUnlock()
	argsForCall := fake.createSecurityGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) CreateSecurityGroupReturns(result1 v7action.Warnings, result2 error) {
	fake.createSecurityGroupMutex.Lock()
	defer fake.createSecurityGroupMutex.Unlock()
	fake.CreateSecurityGroupStub = nil
	fake.createSecurityGroupReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateSecurityGroupReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createSecurityGroupMutex.Lock()
	defer fake.createSecurityGroupMutex.Unlock()
	fake.CreateSecurityGroupStub = nil
	if fake.createSecurityGroupReturnsOnCall == nil {
		fake.createSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createSecurityGroupReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateServiceAppBinding(arg1 v7action.CreateServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.createServiceAppBindingMutex.Lock()
	ret, specificReturn := fake.createServiceAppBindingReturnsOnCall[len(fake.createServiceAppBindingArgsForCall)]
	fake.createServiceAppBindingArgsForCall = append(fake.createServiceAppBindingArgsForCall, struct {
		arg1 v7action.CreateServiceAppBindingParams
	}{arg1})
	fake.recordInvocation("CreateServiceAppBinding", []interface{}{arg1})
	fake.createServiceAppBindingMutex.Unlock()
	if fake.CreateServiceAppBindingStub != nil {
		return fake.CreateServiceAppBindingStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createServiceAppBindingReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateServiceAppBindingCallCount() int {
	fake.createServiceAppBindingMutex.RLock()
	defer fake.createServiceAppBindingMutex.RUnlock()
	return len(fake.createServiceAppBindingArgsForCall)
}

func (fake *FakeActor) CreateServiceAppBindingCalls(stub func(v7action.CreateServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.createServiceAppBindingMutex.Lock()
	defer fake.createServiceAppBindingMutex.Unlock()
	fake.CreateServiceAppBindingStub = stub
}

func (fake *FakeActor) CreateServiceAppBindingArgsForCall(i int) v7action.CreateServiceAppBindingParams {
	fake.createServiceAppBindingMutex.RLock()
	defer fake.createServiceAppBindingMutex.RUnlock()
	argsForCall := fake.createServiceAppBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateServiceAppBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createServiceAppBindingMutex.Lock()
	defer fake.createServiceAppBindingMutex.Unlock()
	fake.CreateServiceAppBindingStub = nil
	fake.createServiceAppBindingReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateServiceAppBindingReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createServiceAppBindingMutex.Lock()
	defer fake.createServiceAppBindingMutex.Unlock()
	fake.CreateServiceAppBindingStub = nil
	if fake.createServiceAppBindingReturnsOnCall == nil {
		fake.createServiceAppBindingReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createServiceAppBindingReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateServiceBroker(arg1 resources.ServiceBroker) (v7action.Warnings, error) {
	fake.createServiceBrokerMutex.Lock()
	ret, specificReturn := fake.createServiceBrokerReturnsOnCall[len(fake.createServiceBrokerArgsForCall)]
	fake.createServiceBrokerArgsForCall = append(fake.createServiceBrokerArgsForCall, struct {
		arg1 resources.ServiceBroker
	}{arg1})
	fake.recordInvocation("CreateServiceBroker", []interface{}{arg1})
	fake.createServiceBrokerMutex.Unlock()
	if fake.CreateServiceBrokerStub != nil {
		return fake.CreateServiceBrokerStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createServiceBrokerReturns
	return fakeReturns.result1, fakeReturns.result2
}

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

func (fake *FakeActor) CreateServiceBrokerCalls(stub func(resources.ServiceBroker) (v7action.Warnings, error)) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = stub
}

func (fake *FakeActor) CreateServiceBrokerArgsForCall(i int) resources.ServiceBroker {
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	argsForCall := fake.createServiceBrokerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateServiceBrokerReturns(result1 v7action.Warnings, result2 error) {
	fake.createServiceBrokerMutex.Lock()
	defer fake.createServiceBrokerMutex.Unlock()
	fake.CreateServiceBrokerStub = nil
	fake.createServiceBrokerReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

func (fake *FakeActor) CreateServiceKey(arg1 v7action.CreateServiceKeyParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.createServiceKeyMutex.Lock()
	ret, specificReturn := fake.createServiceKeyReturnsOnCall[len(fake.createServiceKeyArgsForCall)]
	fake.createServiceKeyArgsForCall = append(fake.createServiceKeyArgsForCall, struct {
		arg1 v7action.CreateServiceKeyParams
	}{arg1})
	fake.recordInvocation("CreateServiceKey", []interface{}{arg1})
	fake.createServiceKeyMutex.Unlock()
	if fake.CreateServiceKeyStub != nil {
		return fake.CreateServiceKeyStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.createServiceKeyReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeActor) CreateServiceKeyCalls(stub func(v7action.CreateServiceKeyParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.createServiceKeyMutex.Lock()
	defer fake.createServiceKeyMutex.Unlock()
	fake.CreateServiceKeyStub = stub
}

func (fake *FakeActor) CreateServiceKeyArgsForCall(i int) v7action.CreateServiceKeyParams {
	fake.createServiceKeyMutex.RLock()
	defer fake.createServiceKeyMutex.RUnlock()
	argsForCall := fake.createServiceKeyArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateServiceKeyReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.createServiceKeyMutex.Lock()
	defer fake.createServiceKeyMutex.Unlock()
	fake.CreateServiceKeyStub = nil
	fake.createServiceKeyReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (fake *FakeActor) CreateSpaceQuota(arg1 string, arg2 string, arg3 v7action.QuotaLimits) (v7action.Warnings, error) {
	fake.createSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.createSpaceQuotaReturnsOnCall[len(fake.createSpaceQuotaArgsForCall)]
	fake.createSpaceQuotaArgsForCall = append(fake.createSpaceQuotaArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 v7action.QuotaLimits
	}{arg1, arg2, arg3})
	fake.recordInvocation("CreateSpaceQuota", []interface{}{arg1, arg2, arg3})
	fake.createSpaceQuotaMutex.Unlock()
	if fake.CreateSpaceQuotaStub != nil {
		return fake.CreateSpaceQuotaStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createSpaceQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateSpaceQuotaCallCount() int {
	fake.createSpaceQuotaMutex.RLock()
	defer fake.createSpaceQuotaMutex.RUnlock()
	return len(fake.createSpaceQuotaArgsForCall)
}

func (fake *FakeActor) CreateSpaceQuotaCalls(stub func(string, string, v7action.QuotaLimits) (v7action.Warnings, error)) {
	fake.createSpaceQuotaMutex.Lock()
	defer fake.createSpaceQuotaMutex.Unlock()
	fake.CreateSpaceQuotaStub = stub
}

func (fake *FakeActor) CreateSpaceQuotaArgsForCall(i int) (string, string, v7action.QuotaLimits) {
	fake.createSpaceQuotaMutex.RLock()
	defer fake.createSpaceQuotaMutex.RUnlock()
	argsForCall := fake.createSpaceQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) CreateSpaceQuotaReturns(result1 v7action.Warnings, result2 error) {
	fake.createSpaceQuotaMutex.Lock()
	defer fake.createSpaceQuotaMutex.Unlock()
	fake.CreateSpaceQuotaStub = nil
	fake.createSpaceQuotaReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateSpaceQuotaReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createSpaceQuotaMutex.Lock()
	defer fake.createSpaceQuotaMutex.Unlock()
	fake.CreateSpaceQuotaStub = nil
	if fake.createSpaceQuotaReturnsOnCall == nil {
		fake.createSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createSpaceQuotaReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateSpaceRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 string, arg6 bool) (v7action.Warnings, error) {
	fake.createSpaceRoleMutex.Lock()
	ret, specificReturn := fake.createSpaceRoleReturnsOnCall[len(fake.createSpaceRoleArgsForCall)]
	fake.createSpaceRoleArgsForCall = append(fake.createSpaceRoleArgsForCall, struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 string
		arg6 bool
	}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.recordInvocation("CreateSpaceRole", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.createSpaceRoleMutex.Unlock()
	if fake.CreateSpaceRoleStub != nil {
		return fake.CreateSpaceRoleStub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createSpaceRoleReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateSpaceRoleCallCount() int {
	fake.createSpaceRoleMutex.RLock()
	defer fake.createSpaceRoleMutex.RUnlock()
	return len(fake.createSpaceRoleArgsForCall)
}

func (fake *FakeActor) CreateSpaceRoleCalls(stub func(constanta.RoleType, string, string, string, string, bool) (v7action.Warnings, error)) {
	fake.createSpaceRoleMutex.Lock()
	defer fake.createSpaceRoleMutex.Unlock()
	fake.CreateSpaceRoleStub = stub
}

func (fake *FakeActor) CreateSpaceRoleArgsForCall(i int) (constanta.RoleType, string, string, string, string, bool) {
	fake.createSpaceRoleMutex.RLock()
	defer fake.createSpaceRoleMutex.RUnlock()
	argsForCall := fake.createSpaceRoleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeActor) CreateSpaceRoleReturns(result1 v7action.Warnings, result2 error) {
	fake.createSpaceRoleMutex.Lock()
	defer fake.createSpaceRoleMutex.Unlock()
	fake.CreateSpaceRoleStub = nil
	fake.createSpaceRoleReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateSpaceRoleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createSpaceRoleMutex.Lock()
	defer fake.createSpaceRoleMutex.Unlock()
	fake.CreateSpaceRoleStub = nil
	if fake.createSpaceRoleReturnsOnCall == nil {
		fake.createSpaceRoleReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createSpaceRoleReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

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

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

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

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

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

func (fake *FakeActor) CreateUserProvidedServiceInstance(arg1 resources.ServiceInstance) (v7action.Warnings, error) {
	fake.createUserProvidedServiceInstanceMutex.Lock()
	ret, specificReturn := fake.createUserProvidedServiceInstanceReturnsOnCall[len(fake.createUserProvidedServiceInstanceArgsForCall)]
	fake.createUserProvidedServiceInstanceArgsForCall = append(fake.createUserProvidedServiceInstanceArgsForCall, struct {
		arg1 resources.ServiceInstance
	}{arg1})
	fake.recordInvocation("CreateUserProvidedServiceInstance", []interface{}{arg1})
	fake.createUserProvidedServiceInstanceMutex.Unlock()
	if fake.CreateUserProvidedServiceInstanceStub != nil {
		return fake.CreateUserProvidedServiceInstanceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.createUserProvidedServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) CreateUserProvidedServiceInstanceCallCount() int {
	fake.createUserProvidedServiceInstanceMutex.RLock()
	defer fake.createUserProvidedServiceInstanceMutex.RUnlock()
	return len(fake.createUserProvidedServiceInstanceArgsForCall)
}

func (fake *FakeActor) CreateUserProvidedServiceInstanceCalls(stub func(resources.ServiceInstance) (v7action.Warnings, error)) {
	fake.createUserProvidedServiceInstanceMutex.Lock()
	defer fake.createUserProvidedServiceInstanceMutex.Unlock()
	fake.CreateUserProvidedServiceInstanceStub = stub
}

func (fake *FakeActor) CreateUserProvidedServiceInstanceArgsForCall(i int) resources.ServiceInstance {
	fake.createUserProvidedServiceInstanceMutex.RLock()
	defer fake.createUserProvidedServiceInstanceMutex.RUnlock()
	argsForCall := fake.createUserProvidedServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateUserProvidedServiceInstanceReturns(result1 v7action.Warnings, result2 error) {
	fake.createUserProvidedServiceInstanceMutex.Lock()
	defer fake.createUserProvidedServiceInstanceMutex.Unlock()
	fake.CreateUserProvidedServiceInstanceStub = nil
	fake.createUserProvidedServiceInstanceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) CreateUserProvidedServiceInstanceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.createUserProvidedServiceInstanceMutex.Lock()
	defer fake.createUserProvidedServiceInstanceMutex.Unlock()
	fake.CreateUserProvidedServiceInstanceStub = nil
	if fake.createUserProvidedServiceInstanceReturnsOnCall == nil {
		fake.createUserProvidedServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.createUserProvidedServiceInstanceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteApplicationByNameAndSpace(arg1 string, arg2 string, arg3 bool) (v7action.Warnings, error) {
	fake.deleteApplicationByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.deleteApplicationByNameAndSpaceReturnsOnCall[len(fake.deleteApplicationByNameAndSpaceArgsForCall)]
	fake.deleteApplicationByNameAndSpaceArgsForCall = append(fake.deleteApplicationByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("DeleteApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.deleteApplicationByNameAndSpaceMutex.Unlock()
	if fake.DeleteApplicationByNameAndSpaceStub != nil {
		return fake.DeleteApplicationByNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteApplicationByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteApplicationByNameAndSpaceCallCount() int {
	fake.deleteApplicationByNameAndSpaceMutex.RLock()
	defer fake.deleteApplicationByNameAndSpaceMutex.RUnlock()
	return len(fake.deleteApplicationByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) DeleteApplicationByNameAndSpaceCalls(stub func(string, string, bool) (v7action.Warnings, error)) {
	fake.deleteApplicationByNameAndSpaceMutex.Lock()
	defer fake.deleteApplicationByNameAndSpaceMutex.Unlock()
	fake.DeleteApplicationByNameAndSpaceStub = stub
}

func (fake *FakeActor) DeleteApplicationByNameAndSpaceArgsForCall(i int) (string, string, bool) {
	fake.deleteApplicationByNameAndSpaceMutex.RLock()
	defer fake.deleteApplicationByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.deleteApplicationByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) DeleteApplicationByNameAndSpaceReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteApplicationByNameAndSpaceMutex.Lock()
	defer fake.deleteApplicationByNameAndSpaceMutex.Unlock()
	fake.DeleteApplicationByNameAndSpaceStub = nil
	fake.deleteApplicationByNameAndSpaceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteApplicationByNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteApplicationByNameAndSpaceMutex.Lock()
	defer fake.deleteApplicationByNameAndSpaceMutex.Unlock()
	fake.DeleteApplicationByNameAndSpaceStub = nil
	if fake.deleteApplicationByNameAndSpaceReturnsOnCall == nil {
		fake.deleteApplicationByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteApplicationByNameAndSpaceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteBuildpackByNameAndStack(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.deleteBuildpackByNameAndStackMutex.Lock()
	ret, specificReturn := fake.deleteBuildpackByNameAndStackReturnsOnCall[len(fake.deleteBuildpackByNameAndStackArgsForCall)]
	fake.deleteBuildpackByNameAndStackArgsForCall = append(fake.deleteBuildpackByNameAndStackArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteBuildpackByNameAndStack", []interface{}{arg1, arg2})
	fake.deleteBuildpackByNameAndStackMutex.Unlock()
	if fake.DeleteBuildpackByNameAndStackStub != nil {
		return fake.DeleteBuildpackByNameAndStackStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteBuildpackByNameAndStackReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackCallCount() int {
	fake.deleteBuildpackByNameAndStackMutex.RLock()
	defer fake.deleteBuildpackByNameAndStackMutex.RUnlock()
	return len(fake.deleteBuildpackByNameAndStackArgsForCall)
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.deleteBuildpackByNameAndStackMutex.Lock()
	defer fake.deleteBuildpackByNameAndStackMutex.Unlock()
	fake.DeleteBuildpackByNameAndStackStub = stub
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackArgsForCall(i int) (string, string) {
	fake.deleteBuildpackByNameAndStackMutex.RLock()
	defer fake.deleteBuildpackByNameAndStackMutex.RUnlock()
	argsForCall := fake.deleteBuildpackByNameAndStackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteBuildpackByNameAndStackMutex.Lock()
	defer fake.deleteBuildpackByNameAndStackMutex.Unlock()
	fake.DeleteBuildpackByNameAndStackStub = nil
	fake.deleteBuildpackByNameAndStackReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteBuildpackByNameAndStackMutex.Lock()
	defer fake.deleteBuildpackByNameAndStackMutex.Unlock()
	fake.DeleteBuildpackByNameAndStackStub = nil
	if fake.deleteBuildpackByNameAndStackReturnsOnCall == nil {
		fake.deleteBuildpackByNameAndStackReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteBuildpackByNameAndStackReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

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

func (fake *FakeActor) DeleteDomainCalls(stub func(resources.Domain) (v7action.Warnings, error)) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = stub
}

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

func (fake *FakeActor) DeleteDomainReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteDomainMutex.Lock()
	defer fake.deleteDomainMutex.Unlock()
	fake.DeleteDomainStub = nil
	fake.deleteDomainReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex(arg1 string, arg2 string, arg3 string, arg4 int) (v7action.Warnings, error) {
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	ret, specificReturn := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall[len(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall)]
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall = append(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 int
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex", []interface{}{arg1, arg2, arg3, arg4})
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	if fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub != nil {
		return fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexCallCount() int {
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RLock()
	defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock()
	return len(fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall)
}

func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexCalls(stub func(string, string, string, int) (v7action.Warnings, error)) {
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub = stub
}

func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall(i int) (string, string, string, int) {
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RLock()
	defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock()
	argsForCall := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub = nil
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub = nil
	if fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall == nil {
		fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteIsolationSegmentByName(arg1 string) (v7action.Warnings, error) {
	fake.deleteIsolationSegmentByNameMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentByNameReturnsOnCall[len(fake.deleteIsolationSegmentByNameArgsForCall)]
	fake.deleteIsolationSegmentByNameArgsForCall = append(fake.deleteIsolationSegmentByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteIsolationSegmentByName", []interface{}{arg1})
	fake.deleteIsolationSegmentByNameMutex.Unlock()
	if fake.DeleteIsolationSegmentByNameStub != nil {
		return fake.DeleteIsolationSegmentByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteIsolationSegmentByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteIsolationSegmentByNameCallCount() int {
	fake.deleteIsolationSegmentByNameMutex.RLock()
	defer fake.deleteIsolationSegmentByNameMutex.RUnlock()
	return len(fake.deleteIsolationSegmentByNameArgsForCall)
}

func (fake *FakeActor) DeleteIsolationSegmentByNameCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteIsolationSegmentByNameMutex.Lock()
	defer fake.deleteIsolationSegmentByNameMutex.Unlock()
	fake.DeleteIsolationSegmentByNameStub = stub
}

func (fake *FakeActor) DeleteIsolationSegmentByNameArgsForCall(i int) string {
	fake.deleteIsolationSegmentByNameMutex.RLock()
	defer fake.deleteIsolationSegmentByNameMutex.RUnlock()
	argsForCall := fake.deleteIsolationSegmentByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteIsolationSegmentByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteIsolationSegmentByNameMutex.Lock()
	defer fake.deleteIsolationSegmentByNameMutex.Unlock()
	fake.DeleteIsolationSegmentByNameStub = nil
	fake.deleteIsolationSegmentByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteIsolationSegmentByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteIsolationSegmentByNameMutex.Lock()
	defer fake.deleteIsolationSegmentByNameMutex.Unlock()
	fake.DeleteIsolationSegmentByNameStub = nil
	if fake.deleteIsolationSegmentByNameReturnsOnCall == nil {
		fake.deleteIsolationSegmentByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteIsolationSegmentByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteIsolationSegmentOrganizationByName(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.deleteIsolationSegmentOrganizationByNameMutex.Lock()
	ret, specificReturn := fake.deleteIsolationSegmentOrganizationByNameReturnsOnCall[len(fake.deleteIsolationSegmentOrganizationByNameArgsForCall)]
	fake.deleteIsolationSegmentOrganizationByNameArgsForCall = append(fake.deleteIsolationSegmentOrganizationByNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteIsolationSegmentOrganizationByName", []interface{}{arg1, arg2})
	fake.deleteIsolationSegmentOrganizationByNameMutex.Unlock()
	if fake.DeleteIsolationSegmentOrganizationByNameStub != nil {
		return fake.DeleteIsolationSegmentOrganizationByNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteIsolationSegmentOrganizationByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameCallCount() int {
	fake.deleteIsolationSegmentOrganizationByNameMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationByNameMutex.RUnlock()
	return len(fake.deleteIsolationSegmentOrganizationByNameArgsForCall)
}

func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.deleteIsolationSegmentOrganizationByNameMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationByNameMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationByNameStub = stub
}

func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameArgsForCall(i int) (string, string) {
	fake.deleteIsolationSegmentOrganizationByNameMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationByNameMutex.RUnlock()
	argsForCall := fake.deleteIsolationSegmentOrganizationByNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteIsolationSegmentOrganizationByNameMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationByNameMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationByNameStub = nil
	fake.deleteIsolationSegmentOrganizationByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteIsolationSegmentOrganizationByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteIsolationSegmentOrganizationByNameMutex.Lock()
	defer fake.deleteIsolationSegmentOrganizationByNameMutex.Unlock()
	fake.DeleteIsolationSegmentOrganizationByNameStub = nil
	if fake.deleteIsolationSegmentOrganizationByNameReturnsOnCall == nil {
		fake.deleteIsolationSegmentOrganizationByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteIsolationSegmentOrganizationByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrgRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 bool) (v7action.Warnings, error) {
	fake.deleteOrgRoleMutex.Lock()
	ret, specificReturn := fake.deleteOrgRoleReturnsOnCall[len(fake.deleteOrgRoleArgsForCall)]
	fake.deleteOrgRoleArgsForCall = append(fake.deleteOrgRoleArgsForCall, struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 bool
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("DeleteOrgRole", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.deleteOrgRoleMutex.Unlock()
	if fake.DeleteOrgRoleStub != nil {
		return fake.DeleteOrgRoleStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteOrgRoleReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteOrgRoleCallCount() int {
	fake.deleteOrgRoleMutex.RLock()
	defer fake.deleteOrgRoleMutex.RUnlock()
	return len(fake.deleteOrgRoleArgsForCall)
}

func (fake *FakeActor) DeleteOrgRoleCalls(stub func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error)) {
	fake.deleteOrgRoleMutex.Lock()
	defer fake.deleteOrgRoleMutex.Unlock()
	fake.DeleteOrgRoleStub = stub
}

func (fake *FakeActor) DeleteOrgRoleArgsForCall(i int) (constanta.RoleType, string, string, string, bool) {
	fake.deleteOrgRoleMutex.RLock()
	defer fake.deleteOrgRoleMutex.RUnlock()
	argsForCall := fake.deleteOrgRoleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeActor) DeleteOrgRoleReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteOrgRoleMutex.Lock()
	defer fake.deleteOrgRoleMutex.Unlock()
	fake.DeleteOrgRoleStub = nil
	fake.deleteOrgRoleReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrgRoleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteOrgRoleMutex.Lock()
	defer fake.deleteOrgRoleMutex.Unlock()
	fake.DeleteOrgRoleStub = nil
	if fake.deleteOrgRoleReturnsOnCall == nil {
		fake.deleteOrgRoleReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteOrgRoleReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrganization(arg1 string) (v7action.Warnings, error) {
	fake.deleteOrganizationMutex.Lock()
	ret, specificReturn := fake.deleteOrganizationReturnsOnCall[len(fake.deleteOrganizationArgsForCall)]
	fake.deleteOrganizationArgsForCall = append(fake.deleteOrganizationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteOrganization", []interface{}{arg1})
	fake.deleteOrganizationMutex.Unlock()
	if fake.DeleteOrganizationStub != nil {
		return fake.DeleteOrganizationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteOrganizationCallCount() int {
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	return len(fake.deleteOrganizationArgsForCall)
}

func (fake *FakeActor) DeleteOrganizationCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteOrganizationMutex.Lock()
	defer fake.deleteOrganizationMutex.Unlock()
	fake.DeleteOrganizationStub = stub
}

func (fake *FakeActor) DeleteOrganizationArgsForCall(i int) string {
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	argsForCall := fake.deleteOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteOrganizationReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteOrganizationMutex.Lock()
	defer fake.deleteOrganizationMutex.Unlock()
	fake.DeleteOrganizationStub = nil
	fake.deleteOrganizationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrganizationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteOrganizationMutex.Lock()
	defer fake.deleteOrganizationMutex.Unlock()
	fake.DeleteOrganizationStub = nil
	if fake.deleteOrganizationReturnsOnCall == nil {
		fake.deleteOrganizationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteOrganizationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrganizationQuota(arg1 string) (v7action.Warnings, error) {
	fake.deleteOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.deleteOrganizationQuotaReturnsOnCall[len(fake.deleteOrganizationQuotaArgsForCall)]
	fake.deleteOrganizationQuotaArgsForCall = append(fake.deleteOrganizationQuotaArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteOrganizationQuota", []interface{}{arg1})
	fake.deleteOrganizationQuotaMutex.Unlock()
	if fake.DeleteOrganizationQuotaStub != nil {
		return fake.DeleteOrganizationQuotaStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteOrganizationQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteOrganizationQuotaCallCount() int {
	fake.deleteOrganizationQuotaMutex.RLock()
	defer fake.deleteOrganizationQuotaMutex.RUnlock()
	return len(fake.deleteOrganizationQuotaArgsForCall)
}

func (fake *FakeActor) DeleteOrganizationQuotaCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteOrganizationQuotaMutex.Lock()
	defer fake.deleteOrganizationQuotaMutex.Unlock()
	fake.DeleteOrganizationQuotaStub = stub
}

func (fake *FakeActor) DeleteOrganizationQuotaArgsForCall(i int) string {
	fake.deleteOrganizationQuotaMutex.RLock()
	defer fake.deleteOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.deleteOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteOrganizationQuotaReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteOrganizationQuotaMutex.Lock()
	defer fake.deleteOrganizationQuotaMutex.Unlock()
	fake.DeleteOrganizationQuotaStub = nil
	fake.deleteOrganizationQuotaReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrganizationQuotaReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteOrganizationQuotaMutex.Lock()
	defer fake.deleteOrganizationQuotaMutex.Unlock()
	fake.DeleteOrganizationQuotaStub = nil
	if fake.deleteOrganizationQuotaReturnsOnCall == nil {
		fake.deleteOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteOrganizationQuotaReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrphanedRoutes(arg1 string) (v7action.Warnings, error) {
	fake.deleteOrphanedRoutesMutex.Lock()
	ret, specificReturn := fake.deleteOrphanedRoutesReturnsOnCall[len(fake.deleteOrphanedRoutesArgsForCall)]
	fake.deleteOrphanedRoutesArgsForCall = append(fake.deleteOrphanedRoutesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteOrphanedRoutes", []interface{}{arg1})
	fake.deleteOrphanedRoutesMutex.Unlock()
	if fake.DeleteOrphanedRoutesStub != nil {
		return fake.DeleteOrphanedRoutesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteOrphanedRoutesReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteOrphanedRoutesCallCount() int {
	fake.deleteOrphanedRoutesMutex.RLock()
	defer fake.deleteOrphanedRoutesMutex.RUnlock()
	return len(fake.deleteOrphanedRoutesArgsForCall)
}

func (fake *FakeActor) DeleteOrphanedRoutesCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteOrphanedRoutesMutex.Lock()
	defer fake.deleteOrphanedRoutesMutex.Unlock()
	fake.DeleteOrphanedRoutesStub = stub
}

func (fake *FakeActor) DeleteOrphanedRoutesArgsForCall(i int) string {
	fake.deleteOrphanedRoutesMutex.RLock()
	defer fake.deleteOrphanedRoutesMutex.RUnlock()
	argsForCall := fake.deleteOrphanedRoutesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteOrphanedRoutesReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteOrphanedRoutesMutex.Lock()
	defer fake.deleteOrphanedRoutesMutex.Unlock()
	fake.DeleteOrphanedRoutesStub = nil
	fake.deleteOrphanedRoutesReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteOrphanedRoutesReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteOrphanedRoutesMutex.Lock()
	defer fake.deleteOrphanedRoutesMutex.Unlock()
	fake.DeleteOrphanedRoutesStub = nil
	if fake.deleteOrphanedRoutesReturnsOnCall == nil {
		fake.deleteOrphanedRoutesReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteOrphanedRoutesReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

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

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

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

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

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

func (fake *FakeActor) DeleteRouteBinding(arg1 v7action.DeleteRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.deleteRouteBindingMutex.Lock()
	ret, specificReturn := fake.deleteRouteBindingReturnsOnCall[len(fake.deleteRouteBindingArgsForCall)]
	fake.deleteRouteBindingArgsForCall = append(fake.deleteRouteBindingArgsForCall, struct {
		arg1 v7action.DeleteRouteBindingParams
	}{arg1})
	fake.recordInvocation("DeleteRouteBinding", []interface{}{arg1})
	fake.deleteRouteBindingMutex.Unlock()
	if fake.DeleteRouteBindingStub != nil {
		return fake.DeleteRouteBindingStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteRouteBindingReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DeleteRouteBindingCallCount() int {
	fake.deleteRouteBindingMutex.RLock()
	defer fake.deleteRouteBindingMutex.RUnlock()
	return len(fake.deleteRouteBindingArgsForCall)
}

func (fake *FakeActor) DeleteRouteBindingCalls(stub func(v7action.DeleteRouteBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.deleteRouteBindingMutex.Lock()
	defer fake.deleteRouteBindingMutex.Unlock()
	fake.DeleteRouteBindingStub = stub
}

func (fake *FakeActor) DeleteRouteBindingArgsForCall(i int) v7action.DeleteRouteBindingParams {
	fake.deleteRouteBindingMutex.RLock()
	defer fake.deleteRouteBindingMutex.RUnlock()
	argsForCall := fake.deleteRouteBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteRouteBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteRouteBindingMutex.Lock()
	defer fake.deleteRouteBindingMutex.Unlock()
	fake.DeleteRouteBindingStub = nil
	fake.deleteRouteBindingReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteRouteBindingReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteRouteBindingMutex.Lock()
	defer fake.deleteRouteBindingMutex.Unlock()
	fake.DeleteRouteBindingStub = nil
	if fake.deleteRouteBindingReturnsOnCall == nil {
		fake.deleteRouteBindingReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.deleteRouteBindingReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteSecurityGroup(arg1 string) (v7action.Warnings, error) {
	fake.deleteSecurityGroupMutex.Lock()
	ret, specificReturn := fake.deleteSecurityGroupReturnsOnCall[len(fake.deleteSecurityGroupArgsForCall)]
	fake.deleteSecurityGroupArgsForCall = append(fake.deleteSecurityGroupArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteSecurityGroup", []interface{}{arg1})
	fake.deleteSecurityGroupMutex.Unlock()
	if fake.DeleteSecurityGroupStub != nil {
		return fake.DeleteSecurityGroupStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteSecurityGroupReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteSecurityGroupCallCount() int {
	fake.deleteSecurityGroupMutex.RLock()
	defer fake.deleteSecurityGroupMutex.RUnlock()
	return len(fake.deleteSecurityGroupArgsForCall)
}

func (fake *FakeActor) DeleteSecurityGroupCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteSecurityGroupMutex.Lock()
	defer fake.deleteSecurityGroupMutex.Unlock()
	fake.DeleteSecurityGroupStub = stub
}

func (fake *FakeActor) DeleteSecurityGroupArgsForCall(i int) string {
	fake.deleteSecurityGroupMutex.RLock()
	defer fake.deleteSecurityGroupMutex.RUnlock()
	argsForCall := fake.deleteSecurityGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteSecurityGroupReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteSecurityGroupMutex.Lock()
	defer fake.deleteSecurityGroupMutex.Unlock()
	fake.DeleteSecurityGroupStub = nil
	fake.deleteSecurityGroupReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteSecurityGroupReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteSecurityGroupMutex.Lock()
	defer fake.deleteSecurityGroupMutex.Unlock()
	fake.DeleteSecurityGroupStub = nil
	if fake.deleteSecurityGroupReturnsOnCall == nil {
		fake.deleteSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteSecurityGroupReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteServiceAppBinding(arg1 v7action.DeleteServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.deleteServiceAppBindingMutex.Lock()
	ret, specificReturn := fake.deleteServiceAppBindingReturnsOnCall[len(fake.deleteServiceAppBindingArgsForCall)]
	fake.deleteServiceAppBindingArgsForCall = append(fake.deleteServiceAppBindingArgsForCall, struct {
		arg1 v7action.DeleteServiceAppBindingParams
	}{arg1})
	fake.recordInvocation("DeleteServiceAppBinding", []interface{}{arg1})
	fake.deleteServiceAppBindingMutex.Unlock()
	if fake.DeleteServiceAppBindingStub != nil {
		return fake.DeleteServiceAppBindingStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteServiceAppBindingReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DeleteServiceAppBindingCallCount() int {
	fake.deleteServiceAppBindingMutex.RLock()
	defer fake.deleteServiceAppBindingMutex.RUnlock()
	return len(fake.deleteServiceAppBindingArgsForCall)
}

func (fake *FakeActor) DeleteServiceAppBindingCalls(stub func(v7action.DeleteServiceAppBindingParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.deleteServiceAppBindingMutex.Lock()
	defer fake.deleteServiceAppBindingMutex.Unlock()
	fake.DeleteServiceAppBindingStub = stub
}

func (fake *FakeActor) DeleteServiceAppBindingArgsForCall(i int) v7action.DeleteServiceAppBindingParams {
	fake.deleteServiceAppBindingMutex.RLock()
	defer fake.deleteServiceAppBindingMutex.RUnlock()
	argsForCall := fake.deleteServiceAppBindingArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteServiceAppBindingReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteServiceAppBindingMutex.Lock()
	defer fake.deleteServiceAppBindingMutex.Unlock()
	fake.DeleteServiceAppBindingStub = nil
	fake.deleteServiceAppBindingReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteServiceAppBindingReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteServiceAppBindingMutex.Lock()
	defer fake.deleteServiceAppBindingMutex.Unlock()
	fake.DeleteServiceAppBindingStub = nil
	if fake.deleteServiceAppBindingReturnsOnCall == nil {
		fake.deleteServiceAppBindingReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.deleteServiceAppBindingReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteServiceBroker(arg1 string) (v7action.Warnings, error) {
	fake.deleteServiceBrokerMutex.Lock()
	ret, specificReturn := fake.deleteServiceBrokerReturnsOnCall[len(fake.deleteServiceBrokerArgsForCall)]
	fake.deleteServiceBrokerArgsForCall = append(fake.deleteServiceBrokerArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteServiceBroker", []interface{}{arg1})
	fake.deleteServiceBrokerMutex.Unlock()
	if fake.DeleteServiceBrokerStub != nil {
		return fake.DeleteServiceBrokerStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteServiceBrokerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteServiceBrokerCallCount() int {
	fake.deleteServiceBrokerMutex.RLock()
	defer fake.deleteServiceBrokerMutex.RUnlock()
	return len(fake.deleteServiceBrokerArgsForCall)
}

func (fake *FakeActor) DeleteServiceBrokerCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteServiceBrokerMutex.Lock()
	defer fake.deleteServiceBrokerMutex.Unlock()
	fake.DeleteServiceBrokerStub = stub
}

func (fake *FakeActor) DeleteServiceBrokerArgsForCall(i int) string {
	fake.deleteServiceBrokerMutex.RLock()
	defer fake.deleteServiceBrokerMutex.RUnlock()
	argsForCall := fake.deleteServiceBrokerArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteServiceBrokerReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteServiceBrokerMutex.Lock()
	defer fake.deleteServiceBrokerMutex.Unlock()
	fake.DeleteServiceBrokerStub = nil
	fake.deleteServiceBrokerReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteServiceBrokerReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteServiceBrokerMutex.Lock()
	defer fake.deleteServiceBrokerMutex.Unlock()
	fake.DeleteServiceBrokerStub = nil
	if fake.deleteServiceBrokerReturnsOnCall == nil {
		fake.deleteServiceBrokerReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteServiceBrokerReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteServiceInstance(arg1 string, arg2 string) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.deleteServiceInstanceMutex.Lock()
	ret, specificReturn := fake.deleteServiceInstanceReturnsOnCall[len(fake.deleteServiceInstanceArgsForCall)]
	fake.deleteServiceInstanceArgsForCall = append(fake.deleteServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteServiceInstance", []interface{}{arg1, arg2})
	fake.deleteServiceInstanceMutex.Unlock()
	if fake.DeleteServiceInstanceStub != nil {
		return fake.DeleteServiceInstanceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DeleteServiceInstanceCallCount() int {
	fake.deleteServiceInstanceMutex.RLock()
	defer fake.deleteServiceInstanceMutex.RUnlock()
	return len(fake.deleteServiceInstanceArgsForCall)
}

func (fake *FakeActor) DeleteServiceInstanceCalls(stub func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.deleteServiceInstanceMutex.Lock()
	defer fake.deleteServiceInstanceMutex.Unlock()
	fake.DeleteServiceInstanceStub = stub
}

func (fake *FakeActor) DeleteServiceInstanceArgsForCall(i int) (string, string) {
	fake.deleteServiceInstanceMutex.RLock()
	defer fake.deleteServiceInstanceMutex.RUnlock()
	argsForCall := fake.deleteServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DeleteServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteServiceInstanceMutex.Lock()
	defer fake.deleteServiceInstanceMutex.Unlock()
	fake.DeleteServiceInstanceStub = nil
	fake.deleteServiceInstanceReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteServiceInstanceReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteServiceInstanceMutex.Lock()
	defer fake.deleteServiceInstanceMutex.Unlock()
	fake.DeleteServiceInstanceStub = nil
	if fake.deleteServiceInstanceReturnsOnCall == nil {
		fake.deleteServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.deleteServiceInstanceReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndName(arg1 string, arg2 string, arg3 string) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.Lock()
	ret, specificReturn := fake.deleteServiceKeyByServiceInstanceAndNameReturnsOnCall[len(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall)]
	fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall = append(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("DeleteServiceKeyByServiceInstanceAndName", []interface{}{arg1, arg2, arg3})
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.Unlock()
	if fake.DeleteServiceKeyByServiceInstanceAndNameStub != nil {
		return fake.DeleteServiceKeyByServiceInstanceAndNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.deleteServiceKeyByServiceInstanceAndNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameCallCount() int {
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.RLock()
	defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.RUnlock()
	return len(fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall)
}

func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameCalls(stub func(string, string, string) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.Lock()
	defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.Unlock()
	fake.DeleteServiceKeyByServiceInstanceAndNameStub = stub
}

func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameArgsForCall(i int) (string, string, string) {
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.RLock()
	defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.RUnlock()
	argsForCall := fake.deleteServiceKeyByServiceInstanceAndNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.Lock()
	defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.Unlock()
	fake.DeleteServiceKeyByServiceInstanceAndNameStub = nil
	fake.deleteServiceKeyByServiceInstanceAndNameReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteServiceKeyByServiceInstanceAndNameReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.Lock()
	defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.Unlock()
	fake.DeleteServiceKeyByServiceInstanceAndNameStub = nil
	if fake.deleteServiceKeyByServiceInstanceAndNameReturnsOnCall == nil {
		fake.deleteServiceKeyByServiceInstanceAndNameReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.deleteServiceKeyByServiceInstanceAndNameReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DeleteSpaceByNameAndOrganizationName(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.deleteSpaceByNameAndOrganizationNameMutex.Lock()
	ret, specificReturn := fake.deleteSpaceByNameAndOrganizationNameReturnsOnCall[len(fake.deleteSpaceByNameAndOrganizationNameArgsForCall)]
	fake.deleteSpaceByNameAndOrganizationNameArgsForCall = append(fake.deleteSpaceByNameAndOrganizationNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteSpaceByNameAndOrganizationName", []interface{}{arg1, arg2})
	fake.deleteSpaceByNameAndOrganizationNameMutex.Unlock()
	if fake.DeleteSpaceByNameAndOrganizationNameStub != nil {
		return fake.DeleteSpaceByNameAndOrganizationNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteSpaceByNameAndOrganizationNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameCallCount() int {
	fake.deleteSpaceByNameAndOrganizationNameMutex.RLock()
	defer fake.deleteSpaceByNameAndOrganizationNameMutex.RUnlock()
	return len(fake.deleteSpaceByNameAndOrganizationNameArgsForCall)
}

func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.deleteSpaceByNameAndOrganizationNameMutex.Lock()
	defer fake.deleteSpaceByNameAndOrganizationNameMutex.Unlock()
	fake.DeleteSpaceByNameAndOrganizationNameStub = stub
}

func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameArgsForCall(i int) (string, string) {
	fake.deleteSpaceByNameAndOrganizationNameMutex.RLock()
	defer fake.deleteSpaceByNameAndOrganizationNameMutex.RUnlock()
	argsForCall := fake.deleteSpaceByNameAndOrganizationNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteSpaceByNameAndOrganizationNameMutex.Lock()
	defer fake.deleteSpaceByNameAndOrganizationNameMutex.Unlock()
	fake.DeleteSpaceByNameAndOrganizationNameStub = nil
	fake.deleteSpaceByNameAndOrganizationNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteSpaceByNameAndOrganizationNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteSpaceByNameAndOrganizationNameMutex.Lock()
	defer fake.deleteSpaceByNameAndOrganizationNameMutex.Unlock()
	fake.DeleteSpaceByNameAndOrganizationNameStub = nil
	if fake.deleteSpaceByNameAndOrganizationNameReturnsOnCall == nil {
		fake.deleteSpaceByNameAndOrganizationNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteSpaceByNameAndOrganizationNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteSpaceQuotaByName(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.deleteSpaceQuotaByNameMutex.Lock()
	ret, specificReturn := fake.deleteSpaceQuotaByNameReturnsOnCall[len(fake.deleteSpaceQuotaByNameArgsForCall)]
	fake.deleteSpaceQuotaByNameArgsForCall = append(fake.deleteSpaceQuotaByNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DeleteSpaceQuotaByName", []interface{}{arg1, arg2})
	fake.deleteSpaceQuotaByNameMutex.Unlock()
	if fake.DeleteSpaceQuotaByNameStub != nil {
		return fake.DeleteSpaceQuotaByNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteSpaceQuotaByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteSpaceQuotaByNameCallCount() int {
	fake.deleteSpaceQuotaByNameMutex.RLock()
	defer fake.deleteSpaceQuotaByNameMutex.RUnlock()
	return len(fake.deleteSpaceQuotaByNameArgsForCall)
}

func (fake *FakeActor) DeleteSpaceQuotaByNameCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.deleteSpaceQuotaByNameMutex.Lock()
	defer fake.deleteSpaceQuotaByNameMutex.Unlock()
	fake.DeleteSpaceQuotaByNameStub = stub
}

func (fake *FakeActor) DeleteSpaceQuotaByNameArgsForCall(i int) (string, string) {
	fake.deleteSpaceQuotaByNameMutex.RLock()
	defer fake.deleteSpaceQuotaByNameMutex.RUnlock()
	argsForCall := fake.deleteSpaceQuotaByNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DeleteSpaceQuotaByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteSpaceQuotaByNameMutex.Lock()
	defer fake.deleteSpaceQuotaByNameMutex.Unlock()
	fake.DeleteSpaceQuotaByNameStub = nil
	fake.deleteSpaceQuotaByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteSpaceQuotaByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteSpaceQuotaByNameMutex.Lock()
	defer fake.deleteSpaceQuotaByNameMutex.Unlock()
	fake.DeleteSpaceQuotaByNameStub = nil
	if fake.deleteSpaceQuotaByNameReturnsOnCall == nil {
		fake.deleteSpaceQuotaByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteSpaceQuotaByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteSpaceRole(arg1 constanta.RoleType, arg2 string, arg3 string, arg4 string, arg5 bool) (v7action.Warnings, error) {
	fake.deleteSpaceRoleMutex.Lock()
	ret, specificReturn := fake.deleteSpaceRoleReturnsOnCall[len(fake.deleteSpaceRoleArgsForCall)]
	fake.deleteSpaceRoleArgsForCall = append(fake.deleteSpaceRoleArgsForCall, struct {
		arg1 constanta.RoleType
		arg2 string
		arg3 string
		arg4 string
		arg5 bool
	}{arg1, arg2, arg3, arg4, arg5})
	fake.recordInvocation("DeleteSpaceRole", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.deleteSpaceRoleMutex.Unlock()
	if fake.DeleteSpaceRoleStub != nil {
		return fake.DeleteSpaceRoleStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteSpaceRoleReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteSpaceRoleCallCount() int {
	fake.deleteSpaceRoleMutex.RLock()
	defer fake.deleteSpaceRoleMutex.RUnlock()
	return len(fake.deleteSpaceRoleArgsForCall)
}

func (fake *FakeActor) DeleteSpaceRoleCalls(stub func(constanta.RoleType, string, string, string, bool) (v7action.Warnings, error)) {
	fake.deleteSpaceRoleMutex.Lock()
	defer fake.deleteSpaceRoleMutex.Unlock()
	fake.DeleteSpaceRoleStub = stub
}

func (fake *FakeActor) DeleteSpaceRoleArgsForCall(i int) (constanta.RoleType, string, string, string, bool) {
	fake.deleteSpaceRoleMutex.RLock()
	defer fake.deleteSpaceRoleMutex.RUnlock()
	argsForCall := fake.deleteSpaceRoleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeActor) DeleteSpaceRoleReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteSpaceRoleMutex.Lock()
	defer fake.deleteSpaceRoleMutex.Unlock()
	fake.DeleteSpaceRoleStub = nil
	fake.deleteSpaceRoleReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteSpaceRoleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteSpaceRoleMutex.Lock()
	defer fake.deleteSpaceRoleMutex.Unlock()
	fake.DeleteSpaceRoleStub = nil
	if fake.deleteSpaceRoleReturnsOnCall == nil {
		fake.deleteSpaceRoleReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteSpaceRoleReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteUser(arg1 string) (v7action.Warnings, error) {
	fake.deleteUserMutex.Lock()
	ret, specificReturn := fake.deleteUserReturnsOnCall[len(fake.deleteUserArgsForCall)]
	fake.deleteUserArgsForCall = append(fake.deleteUserArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DeleteUser", []interface{}{arg1})
	fake.deleteUserMutex.Unlock()
	if fake.DeleteUserStub != nil {
		return fake.DeleteUserStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.deleteUserReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteUserCallCount() int {
	fake.deleteUserMutex.RLock()
	defer fake.deleteUserMutex.RUnlock()
	return len(fake.deleteUserArgsForCall)
}

func (fake *FakeActor) DeleteUserCalls(stub func(string) (v7action.Warnings, error)) {
	fake.deleteUserMutex.Lock()
	defer fake.deleteUserMutex.Unlock()
	fake.DeleteUserStub = stub
}

func (fake *FakeActor) DeleteUserArgsForCall(i int) string {
	fake.deleteUserMutex.RLock()
	defer fake.deleteUserMutex.RUnlock()
	argsForCall := fake.deleteUserArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DeleteUserReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteUserMutex.Lock()
	defer fake.deleteUserMutex.Unlock()
	fake.DeleteUserStub = nil
	fake.deleteUserReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteUserReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteUserMutex.Lock()
	defer fake.deleteUserMutex.Unlock()
	fake.DeleteUserStub = nil
	if fake.deleteUserReturnsOnCall == nil {
		fake.deleteUserReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteUserReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DiffSpaceManifest(arg1 string, arg2 []byte) (resources.ManifestDiff, v7action.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.diffSpaceManifestMutex.Lock()
	ret, specificReturn := fake.diffSpaceManifestReturnsOnCall[len(fake.diffSpaceManifestArgsForCall)]
	fake.diffSpaceManifestArgsForCall = append(fake.diffSpaceManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	fake.recordInvocation("DiffSpaceManifest", []interface{}{arg1, arg2Copy})
	fake.diffSpaceManifestMutex.Unlock()
	if fake.DiffSpaceManifestStub != nil {
		return fake.DiffSpaceManifestStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.diffSpaceManifestReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DiffSpaceManifestCallCount() int {
	fake.diffSpaceManifestMutex.RLock()
	defer fake.diffSpaceManifestMutex.RUnlock()
	return len(fake.diffSpaceManifestArgsForCall)
}

func (fake *FakeActor) DiffSpaceManifestCalls(stub func(string, []byte) (resources.ManifestDiff, v7action.Warnings, error)) {
	fake.diffSpaceManifestMutex.Lock()
	defer fake.diffSpaceManifestMutex.Unlock()
	fake.DiffSpaceManifestStub = stub
}

func (fake *FakeActor) DiffSpaceManifestArgsForCall(i int) (string, []byte) {
	fake.diffSpaceManifestMutex.RLock()
	defer fake.diffSpaceManifestMutex.RUnlock()
	argsForCall := fake.diffSpaceManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DiffSpaceManifestReturns(result1 resources.ManifestDiff, result2 v7action.Warnings, result3 error) {
	fake.diffSpaceManifestMutex.Lock()
	defer fake.diffSpaceManifestMutex.Unlock()
	fake.DiffSpaceManifestStub = nil
	fake.diffSpaceManifestReturns = struct {
		result1 resources.ManifestDiff
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DiffSpaceManifestReturnsOnCall(i int, result1 resources.ManifestDiff, result2 v7action.Warnings, result3 error) {
	fake.diffSpaceManifestMutex.Lock()
	defer fake.diffSpaceManifestMutex.Unlock()
	fake.DiffSpaceManifestStub = nil
	if fake.diffSpaceManifestReturnsOnCall == nil {
		fake.diffSpaceManifestReturnsOnCall = make(map[int]struct {
			result1 resources.ManifestDiff
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.diffSpaceManifestReturnsOnCall[i] = struct {
		result1 resources.ManifestDiff
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DisableFeatureFlag(arg1 string) (v7action.Warnings, error) {
	fake.disableFeatureFlagMutex.Lock()
	ret, specificReturn := fake.disableFeatureFlagReturnsOnCall[len(fake.disableFeatureFlagArgsForCall)]
	fake.disableFeatureFlagArgsForCall = append(fake.disableFeatureFlagArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("DisableFeatureFlag", []interface{}{arg1})
	fake.disableFeatureFlagMutex.Unlock()
	if fake.DisableFeatureFlagStub != nil {
		return fake.DisableFeatureFlagStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.disableFeatureFlagReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DisableFeatureFlagCallCount() int {
	fake.disableFeatureFlagMutex.RLock()
	defer fake.disableFeatureFlagMutex.RUnlock()
	return len(fake.disableFeatureFlagArgsForCall)
}

func (fake *FakeActor) DisableFeatureFlagCalls(stub func(string) (v7action.Warnings, error)) {
	fake.disableFeatureFlagMutex.Lock()
	defer fake.disableFeatureFlagMutex.Unlock()
	fake.DisableFeatureFlagStub = stub
}

func (fake *FakeActor) DisableFeatureFlagArgsForCall(i int) string {
	fake.disableFeatureFlagMutex.RLock()
	defer fake.disableFeatureFlagMutex.RUnlock()
	argsForCall := fake.disableFeatureFlagArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) DisableFeatureFlagReturns(result1 v7action.Warnings, result2 error) {
	fake.disableFeatureFlagMutex.Lock()
	defer fake.disableFeatureFlagMutex.Unlock()
	fake.DisableFeatureFlagStub = nil
	fake.disableFeatureFlagReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DisableFeatureFlagReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.disableFeatureFlagMutex.Lock()
	defer fake.disableFeatureFlagMutex.Unlock()
	fake.DisableFeatureFlagStub = nil
	if fake.disableFeatureFlagReturnsOnCall == nil {
		fake.disableFeatureFlagReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.disableFeatureFlagReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DisableServiceAccess(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.SkippedPlans, v7action.Warnings, error) {
	fake.disableServiceAccessMutex.Lock()
	ret, specificReturn := fake.disableServiceAccessReturnsOnCall[len(fake.disableServiceAccessArgsForCall)]
	fake.disableServiceAccessArgsForCall = append(fake.disableServiceAccessArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("DisableServiceAccess", []interface{}{arg1, arg2, arg3, arg4})
	fake.disableServiceAccessMutex.Unlock()
	if fake.DisableServiceAccessStub != nil {
		return fake.DisableServiceAccessStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.disableServiceAccessReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DisableServiceAccessCallCount() int {
	fake.disableServiceAccessMutex.RLock()
	defer fake.disableServiceAccessMutex.RUnlock()
	return len(fake.disableServiceAccessArgsForCall)
}

func (fake *FakeActor) DisableServiceAccessCalls(stub func(string, string, string, string) (v7action.SkippedPlans, v7action.Warnings, error)) {
	fake.disableServiceAccessMutex.Lock()
	defer fake.disableServiceAccessMutex.Unlock()
	fake.DisableServiceAccessStub = stub
}

func (fake *FakeActor) DisableServiceAccessArgsForCall(i int) (string, string, string, string) {
	fake.disableServiceAccessMutex.RLock()
	defer fake.disableServiceAccessMutex.RUnlock()
	argsForCall := fake.disableServiceAccessArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) DisableServiceAccessReturns(result1 v7action.SkippedPlans, result2 v7action.Warnings, result3 error) {
	fake.disableServiceAccessMutex.Lock()
	defer fake.disableServiceAccessMutex.Unlock()
	fake.DisableServiceAccessStub = nil
	fake.disableServiceAccessReturns = struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DisableServiceAccessReturnsOnCall(i int, result1 v7action.SkippedPlans, result2 v7action.Warnings, result3 error) {
	fake.disableServiceAccessMutex.Lock()
	defer fake.disableServiceAccessMutex.Unlock()
	fake.DisableServiceAccessStub = nil
	if fake.disableServiceAccessReturnsOnCall == nil {
		fake.disableServiceAccessReturnsOnCall = make(map[int]struct {
			result1 v7action.SkippedPlans
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.disableServiceAccessReturnsOnCall[i] = struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DownloadCurrentDropletByAppName(arg1 string, arg2 string) ([]byte, string, v7action.Warnings, error) {
	fake.downloadCurrentDropletByAppNameMutex.Lock()
	ret, specificReturn := fake.downloadCurrentDropletByAppNameReturnsOnCall[len(fake.downloadCurrentDropletByAppNameArgsForCall)]
	fake.downloadCurrentDropletByAppNameArgsForCall = append(fake.downloadCurrentDropletByAppNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("DownloadCurrentDropletByAppName", []interface{}{arg1, arg2})
	fake.downloadCurrentDropletByAppNameMutex.Unlock()
	if fake.DownloadCurrentDropletByAppNameStub != nil {
		return fake.DownloadCurrentDropletByAppNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	fakeReturns := fake.downloadCurrentDropletByAppNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeActor) DownloadCurrentDropletByAppNameCallCount() int {
	fake.downloadCurrentDropletByAppNameMutex.RLock()
	defer fake.downloadCurrentDropletByAppNameMutex.RUnlock()
	return len(fake.downloadCurrentDropletByAppNameArgsForCall)
}

func (fake *FakeActor) DownloadCurrentDropletByAppNameCalls(stub func(string, string) ([]byte, string, v7action.Warnings, error)) {
	fake.downloadCurrentDropletByAppNameMutex.Lock()
	defer fake.downloadCurrentDropletByAppNameMutex.Unlock()
	fake.DownloadCurrentDropletByAppNameStub = stub
}

func (fake *FakeActor) DownloadCurrentDropletByAppNameArgsForCall(i int) (string, string) {
	fake.downloadCurrentDropletByAppNameMutex.RLock()
	defer fake.downloadCurrentDropletByAppNameMutex.RUnlock()
	argsForCall := fake.downloadCurrentDropletByAppNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) DownloadCurrentDropletByAppNameReturns(result1 []byte, result2 string, result3 v7action.Warnings, result4 error) {
	fake.downloadCurrentDropletByAppNameMutex.Lock()
	defer fake.downloadCurrentDropletByAppNameMutex.Unlock()
	fake.DownloadCurrentDropletByAppNameStub = nil
	fake.downloadCurrentDropletByAppNameReturns = struct {
		result1 []byte
		result2 string
		result3 v7action.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeActor) DownloadCurrentDropletByAppNameReturnsOnCall(i int, result1 []byte, result2 string, result3 v7action.Warnings, result4 error) {
	fake.downloadCurrentDropletByAppNameMutex.Lock()
	defer fake.downloadCurrentDropletByAppNameMutex.Unlock()
	fake.DownloadCurrentDropletByAppNameStub = nil
	if fake.downloadCurrentDropletByAppNameReturnsOnCall == nil {
		fake.downloadCurrentDropletByAppNameReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 string
			result3 v7action.Warnings
			result4 error
		})
	}
	fake.downloadCurrentDropletByAppNameReturnsOnCall[i] = struct {
		result1 []byte
		result2 string
		result3 v7action.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeActor) DownloadDropletByGUIDAndAppName(arg1 string, arg2 string, arg3 string) ([]byte, v7action.Warnings, error) {
	fake.downloadDropletByGUIDAndAppNameMutex.Lock()
	ret, specificReturn := fake.downloadDropletByGUIDAndAppNameReturnsOnCall[len(fake.downloadDropletByGUIDAndAppNameArgsForCall)]
	fake.downloadDropletByGUIDAndAppNameArgsForCall = append(fake.downloadDropletByGUIDAndAppNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("DownloadDropletByGUIDAndAppName", []interface{}{arg1, arg2, arg3})
	fake.downloadDropletByGUIDAndAppNameMutex.Unlock()
	if fake.DownloadDropletByGUIDAndAppNameStub != nil {
		return fake.DownloadDropletByGUIDAndAppNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.downloadDropletByGUIDAndAppNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) DownloadDropletByGUIDAndAppNameCallCount() int {
	fake.downloadDropletByGUIDAndAppNameMutex.RLock()
	defer fake.downloadDropletByGUIDAndAppNameMutex.RUnlock()
	return len(fake.downloadDropletByGUIDAndAppNameArgsForCall)
}

func (fake *FakeActor) DownloadDropletByGUIDAndAppNameCalls(stub func(string, string, string) ([]byte, v7action.Warnings, error)) {
	fake.downloadDropletByGUIDAndAppNameMutex.Lock()
	defer fake.downloadDropletByGUIDAndAppNameMutex.Unlock()
	fake.DownloadDropletByGUIDAndAppNameStub = stub
}

func (fake *FakeActor) DownloadDropletByGUIDAndAppNameArgsForCall(i int) (string, string, string) {
	fake.downloadDropletByGUIDAndAppNameMutex.RLock()
	defer fake.downloadDropletByGUIDAndAppNameMutex.RUnlock()
	argsForCall := fake.downloadDropletByGUIDAndAppNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) DownloadDropletByGUIDAndAppNameReturns(result1 []byte, result2 v7action.Warnings, result3 error) {
	fake.downloadDropletByGUIDAndAppNameMutex.Lock()
	defer fake.downloadDropletByGUIDAndAppNameMutex.Unlock()
	fake.DownloadDropletByGUIDAndAppNameStub = nil
	fake.downloadDropletByGUIDAndAppNameReturns = struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) DownloadDropletByGUIDAndAppNameReturnsOnCall(i int, result1 []byte, result2 v7action.Warnings, result3 error) {
	fake.downloadDropletByGUIDAndAppNameMutex.Lock()
	defer fake.downloadDropletByGUIDAndAppNameMutex.Unlock()
	fake.DownloadDropletByGUIDAndAppNameStub = nil
	if fake.downloadDropletByGUIDAndAppNameReturnsOnCall == nil {
		fake.downloadDropletByGUIDAndAppNameReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.downloadDropletByGUIDAndAppNameReturnsOnCall[i] = struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) EnableFeatureFlag(arg1 string) (v7action.Warnings, error) {
	fake.enableFeatureFlagMutex.Lock()
	ret, specificReturn := fake.enableFeatureFlagReturnsOnCall[len(fake.enableFeatureFlagArgsForCall)]
	fake.enableFeatureFlagArgsForCall = append(fake.enableFeatureFlagArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("EnableFeatureFlag", []interface{}{arg1})
	fake.enableFeatureFlagMutex.Unlock()
	if fake.EnableFeatureFlagStub != nil {
		return fake.EnableFeatureFlagStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.enableFeatureFlagReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) EnableFeatureFlagCallCount() int {
	fake.enableFeatureFlagMutex.RLock()
	defer fake.enableFeatureFlagMutex.RUnlock()
	return len(fake.enableFeatureFlagArgsForCall)
}

func (fake *FakeActor) EnableFeatureFlagCalls(stub func(string) (v7action.Warnings, error)) {
	fake.enableFeatureFlagMutex.Lock()
	defer fake.enableFeatureFlagMutex.Unlock()
	fake.EnableFeatureFlagStub = stub
}

func (fake *FakeActor) EnableFeatureFlagArgsForCall(i int) string {
	fake.enableFeatureFlagMutex.RLock()
	defer fake.enableFeatureFlagMutex.RUnlock()
	argsForCall := fake.enableFeatureFlagArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) EnableFeatureFlagReturns(result1 v7action.Warnings, result2 error) {
	fake.enableFeatureFlagMutex.Lock()
	defer fake.enableFeatureFlagMutex.Unlock()
	fake.EnableFeatureFlagStub = nil
	fake.enableFeatureFlagReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) EnableFeatureFlagReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.enableFeatureFlagMutex.Lock()
	defer fake.enableFeatureFlagMutex.Unlock()
	fake.EnableFeatureFlagStub = nil
	if fake.enableFeatureFlagReturnsOnCall == nil {
		fake.enableFeatureFlagReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.enableFeatureFlagReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) EnableServiceAccess(arg1 string, arg2 string, arg3 string, arg4 string) (v7action.SkippedPlans, v7action.Warnings, error) {
	fake.enableServiceAccessMutex.Lock()
	ret, specificReturn := fake.enableServiceAccessReturnsOnCall[len(fake.enableServiceAccessArgsForCall)]
	fake.enableServiceAccessArgsForCall = append(fake.enableServiceAccessArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("EnableServiceAccess", []interface{}{arg1, arg2, arg3, arg4})
	fake.enableServiceAccessMutex.Unlock()
	if fake.EnableServiceAccessStub != nil {
		return fake.EnableServiceAccessStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.enableServiceAccessReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) EnableServiceAccessCallCount() int {
	fake.enableServiceAccessMutex.RLock()
	defer fake.enableServiceAccessMutex.RUnlock()
	return len(fake.enableServiceAccessArgsForCall)
}

func (fake *FakeActor) EnableServiceAccessCalls(stub func(string, string, string, string) (v7action.SkippedPlans, v7action.Warnings, error)) {
	fake.enableServiceAccessMutex.Lock()
	defer fake.enableServiceAccessMutex.Unlock()
	fake.EnableServiceAccessStub = stub
}

func (fake *FakeActor) EnableServiceAccessArgsForCall(i int) (string, string, string, string) {
	fake.enableServiceAccessMutex.RLock()
	defer fake.enableServiceAccessMutex.RUnlock()
	argsForCall := fake.enableServiceAccessArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) EnableServiceAccessReturns(result1 v7action.SkippedPlans, result2 v7action.Warnings, result3 error) {
	fake.enableServiceAccessMutex.Lock()
	defer fake.enableServiceAccessMutex.Unlock()
	fake.EnableServiceAccessStub = nil
	fake.enableServiceAccessReturns = struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) EnableServiceAccessReturnsOnCall(i int, result1 v7action.SkippedPlans, result2 v7action.Warnings, result3 error) {
	fake.enableServiceAccessMutex.Lock()
	defer fake.enableServiceAccessMutex.Unlock()
	fake.EnableServiceAccessStub = nil
	if fake.enableServiceAccessReturnsOnCall == nil {
		fake.enableServiceAccessReturnsOnCall = make(map[int]struct {
			result1 v7action.SkippedPlans
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.enableServiceAccessReturnsOnCall[i] = struct {
		result1 v7action.SkippedPlans
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByName(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.entitleIsolationSegmentToOrganizationByNameMutex.Lock()
	ret, specificReturn := fake.entitleIsolationSegmentToOrganizationByNameReturnsOnCall[len(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall)]
	fake.entitleIsolationSegmentToOrganizationByNameArgsForCall = append(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("EntitleIsolationSegmentToOrganizationByName", []interface{}{arg1, arg2})
	fake.entitleIsolationSegmentToOrganizationByNameMutex.Unlock()
	if fake.EntitleIsolationSegmentToOrganizationByNameStub != nil {
		return fake.EntitleIsolationSegmentToOrganizationByNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.entitleIsolationSegmentToOrganizationByNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameCallCount() int {
	fake.entitleIsolationSegmentToOrganizationByNameMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationByNameMutex.RUnlock()
	return len(fake.entitleIsolationSegmentToOrganizationByNameArgsForCall)
}

func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.entitleIsolationSegmentToOrganizationByNameMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationByNameMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationByNameStub = stub
}

func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameArgsForCall(i int) (string, string) {
	fake.entitleIsolationSegmentToOrganizationByNameMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationByNameMutex.RUnlock()
	argsForCall := fake.entitleIsolationSegmentToOrganizationByNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameReturns(result1 v7action.Warnings, result2 error) {
	fake.entitleIsolationSegmentToOrganizationByNameMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationByNameMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationByNameStub = nil
	fake.entitleIsolationSegmentToOrganizationByNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) EntitleIsolationSegmentToOrganizationByNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.entitleIsolationSegmentToOrganizationByNameMutex.Lock()
	defer fake.entitleIsolationSegmentToOrganizationByNameMutex.Unlock()
	fake.EntitleIsolationSegmentToOrganizationByNameStub = nil
	if fake.entitleIsolationSegmentToOrganizationByNameReturnsOnCall == nil {
		fake.entitleIsolationSegmentToOrganizationByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.entitleIsolationSegmentToOrganizationByNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetAppFeature(arg1 string, arg2 string) (resources.ApplicationFeature, v7action.Warnings, error) {
	fake.getAppFeatureMutex.Lock()
	ret, specificReturn := fake.getAppFeatureReturnsOnCall[len(fake.getAppFeatureArgsForCall)]
	fake.getAppFeatureArgsForCall = append(fake.getAppFeatureArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetAppFeature", []interface{}{arg1, arg2})
	fake.getAppFeatureMutex.Unlock()
	if fake.GetAppFeatureStub != nil {
		return fake.GetAppFeatureStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getAppFeatureReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetAppFeatureCallCount() int {
	fake.getAppFeatureMutex.RLock()
	defer fake.getAppFeatureMutex.RUnlock()
	return len(fake.getAppFeatureArgsForCall)
}

func (fake *FakeActor) GetAppFeatureCalls(stub func(string, string) (resources.ApplicationFeature, v7action.Warnings, error)) {
	fake.getAppFeatureMutex.Lock()
	defer fake.getAppFeatureMutex.Unlock()
	fake.GetAppFeatureStub = stub
}

func (fake *FakeActor) GetAppFeatureArgsForCall(i int) (string, string) {
	fake.getAppFeatureMutex.RLock()
	defer fake.getAppFeatureMutex.RUnlock()
	argsForCall := fake.getAppFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetAppFeatureReturns(result1 resources.ApplicationFeature, result2 v7action.Warnings, result3 error) {
	fake.getAppFeatureMutex.Lock()
	defer fake.getAppFeatureMutex.Unlock()
	fake.GetAppFeatureStub = nil
	fake.getAppFeatureReturns = struct {
		result1 resources.ApplicationFeature
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetAppFeatureReturnsOnCall(i int, result1 resources.ApplicationFeature, result2 v7action.Warnings, result3 error) {
	fake.getAppFeatureMutex.Lock()
	defer fake.getAppFeatureMutex.Unlock()
	fake.GetAppFeatureStub = nil
	if fake.getAppFeatureReturnsOnCall == nil {
		fake.getAppFeatureReturnsOnCall = make(map[int]struct {
			result1 resources.ApplicationFeature
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getAppFeatureReturnsOnCall[i] = struct {
		result1 resources.ApplicationFeature
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetAppSummariesForSpace(arg1 string, arg2 string) ([]v7action.ApplicationSummary, v7action.Warnings, error) {
	fake.getAppSummariesForSpaceMutex.Lock()
	ret, specificReturn := fake.getAppSummariesForSpaceReturnsOnCall[len(fake.getAppSummariesForSpaceArgsForCall)]
	fake.getAppSummariesForSpaceArgsForCall = append(fake.getAppSummariesForSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetAppSummariesForSpace", []interface{}{arg1, arg2})
	fake.getAppSummariesForSpaceMutex.Unlock()
	if fake.GetAppSummariesForSpaceStub != nil {
		return fake.GetAppSummariesForSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getAppSummariesForSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetAppSummariesForSpaceCallCount() int {
	fake.getAppSummariesForSpaceMutex.RLock()
	defer fake.getAppSummariesForSpaceMutex.RUnlock()
	return len(fake.getAppSummariesForSpaceArgsForCall)
}

func (fake *FakeActor) GetAppSummariesForSpaceCalls(stub func(string, string) ([]v7action.ApplicationSummary, v7action.Warnings, error)) {
	fake.getAppSummariesForSpaceMutex.Lock()
	defer fake.getAppSummariesForSpaceMutex.Unlock()
	fake.GetAppSummariesForSpaceStub = stub
}

func (fake *FakeActor) GetAppSummariesForSpaceArgsForCall(i int) (string, string) {
	fake.getAppSummariesForSpaceMutex.RLock()
	defer fake.getAppSummariesForSpaceMutex.RUnlock()
	argsForCall := fake.getAppSummariesForSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetAppSummariesForSpaceReturns(result1 []v7action.ApplicationSummary, result2 v7action.Warnings, result3 error) {
	fake.getAppSummariesForSpaceMutex.Lock()
	defer fake.getAppSummariesForSpaceMutex.Unlock()
	fake.GetAppSummariesForSpaceStub = nil
	fake.getAppSummariesForSpaceReturns = struct {
		result1 []v7action.ApplicationSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetAppSummariesForSpaceReturnsOnCall(i int, result1 []v7action.ApplicationSummary, result2 v7action.Warnings, result3 error) {
	fake.getAppSummariesForSpaceMutex.Lock()
	defer fake.getAppSummariesForSpaceMutex.Unlock()
	fake.GetAppSummariesForSpaceStub = nil
	if fake.getAppSummariesForSpaceReturnsOnCall == nil {
		fake.getAppSummariesForSpaceReturnsOnCall = make(map[int]struct {
			result1 []v7action.ApplicationSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getAppSummariesForSpaceReturnsOnCall[i] = struct {
		result1 []v7action.ApplicationSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationByNameAndSpace(arg1 string, arg2 string) (resources.Application, v7action.Warnings, error) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getApplicationByNameAndSpaceReturnsOnCall[len(fake.getApplicationByNameAndSpaceArgsForCall)]
	fake.getApplicationByNameAndSpaceArgsForCall = append(fake.getApplicationByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationByNameAndSpace", []interface{}{arg1, arg2})
	fake.getApplicationByNameAndSpaceMutex.Unlock()
	if fake.GetApplicationByNameAndSpaceStub != nil {
		return fake.GetApplicationByNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationByNameAndSpaceCallCount() int {
	fake.getApplicationByNameAndSpaceMutex.RLock()
	defer fake.getApplicationByNameAndSpaceMutex.RUnlock()
	return len(fake.getApplicationByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetApplicationByNameAndSpaceCalls(stub func(string, string) (resources.Application, v7action.Warnings, error)) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	defer fake.getApplicationByNameAndSpaceMutex.Unlock()
	fake.GetApplicationByNameAndSpaceStub = stub
}

func (fake *FakeActor) GetApplicationByNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getApplicationByNameAndSpaceMutex.RLock()
	defer fake.getApplicationByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getApplicationByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetApplicationByNameAndSpaceReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	defer fake.getApplicationByNameAndSpaceMutex.Unlock()
	fake.GetApplicationByNameAndSpaceStub = nil
	fake.getApplicationByNameAndSpaceReturns = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationByNameAndSpaceReturnsOnCall(i int, result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationByNameAndSpaceMutex.Lock()
	defer fake.getApplicationByNameAndSpaceMutex.Unlock()
	fake.GetApplicationByNameAndSpaceStub = nil
	if fake.getApplicationByNameAndSpaceReturnsOnCall == nil {
		fake.getApplicationByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationByNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationDroplets(arg1 string, arg2 string) ([]resources.Droplet, v7action.Warnings, error) {
	fake.getApplicationDropletsMutex.Lock()
	ret, specificReturn := fake.getApplicationDropletsReturnsOnCall[len(fake.getApplicationDropletsArgsForCall)]
	fake.getApplicationDropletsArgsForCall = append(fake.getApplicationDropletsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationDroplets", []interface{}{arg1, arg2})
	fake.getApplicationDropletsMutex.Unlock()
	if fake.GetApplicationDropletsStub != nil {
		return fake.GetApplicationDropletsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationDropletsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationDropletsCallCount() int {
	fake.getApplicationDropletsMutex.RLock()
	defer fake.getApplicationDropletsMutex.RUnlock()
	return len(fake.getApplicationDropletsArgsForCall)
}

func (fake *FakeActor) GetApplicationDropletsCalls(stub func(string, string) ([]resources.Droplet, v7action.Warnings, error)) {
	fake.getApplicationDropletsMutex.Lock()
	defer fake.getApplicationDropletsMutex.Unlock()
	fake.GetApplicationDropletsStub = stub
}

func (fake *FakeActor) GetApplicationDropletsArgsForCall(i int) (string, string) {
	fake.getApplicationDropletsMutex.RLock()
	defer fake.getApplicationDropletsMutex.RUnlock()
	argsForCall := fake.getApplicationDropletsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetApplicationDropletsReturns(result1 []resources.Droplet, result2 v7action.Warnings, result3 error) {
	fake.getApplicationDropletsMutex.Lock()
	defer fake.getApplicationDropletsMutex.Unlock()
	fake.GetApplicationDropletsStub = nil
	fake.getApplicationDropletsReturns = struct {
		result1 []resources.Droplet
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationDropletsReturnsOnCall(i int, result1 []resources.Droplet, result2 v7action.Warnings, result3 error) {
	fake.getApplicationDropletsMutex.Lock()
	defer fake.getApplicationDropletsMutex.Unlock()
	fake.GetApplicationDropletsStub = nil
	if fake.getApplicationDropletsReturnsOnCall == nil {
		fake.getApplicationDropletsReturnsOnCall = make(map[int]struct {
			result1 []resources.Droplet
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationDropletsReturnsOnCall[i] = struct {
		result1 []resources.Droplet
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getApplicationLabelsMutex.Lock()
	ret, specificReturn := fake.getApplicationLabelsReturnsOnCall[len(fake.getApplicationLabelsArgsForCall)]
	fake.getApplicationLabelsArgsForCall = append(fake.getApplicationLabelsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationLabels", []interface{}{arg1, arg2})
	fake.getApplicationLabelsMutex.Unlock()
	if fake.GetApplicationLabelsStub != nil {
		return fake.GetApplicationLabelsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationLabelsCallCount() int {
	fake.getApplicationLabelsMutex.RLock()
	defer fake.getApplicationLabelsMutex.RUnlock()
	return len(fake.getApplicationLabelsArgsForCall)
}

func (fake *FakeActor) GetApplicationLabelsCalls(stub func(string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getApplicationLabelsMutex.Lock()
	defer fake.getApplicationLabelsMutex.Unlock()
	fake.GetApplicationLabelsStub = stub
}

func (fake *FakeActor) GetApplicationLabelsArgsForCall(i int) (string, string) {
	fake.getApplicationLabelsMutex.RLock()
	defer fake.getApplicationLabelsMutex.RUnlock()
	argsForCall := fake.getApplicationLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetApplicationLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getApplicationLabelsMutex.Lock()
	defer fake.getApplicationLabelsMutex.Unlock()
	fake.GetApplicationLabelsStub = nil
	fake.getApplicationLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getApplicationLabelsMutex.Lock()
	defer fake.getApplicationLabelsMutex.Unlock()
	fake.GetApplicationLabelsStub = nil
	if fake.getApplicationLabelsReturnsOnCall == nil {
		fake.getApplicationLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationMapForRoute(arg1 resources.Route) (map[string]resources.Application, v7action.Warnings, error) {
	fake.getApplicationMapForRouteMutex.Lock()
	ret, specificReturn := fake.getApplicationMapForRouteReturnsOnCall[len(fake.getApplicationMapForRouteArgsForCall)]
	fake.getApplicationMapForRouteArgsForCall = append(fake.getApplicationMapForRouteArgsForCall, struct {
		arg1 resources.Route
	}{arg1})
	fake.recordInvocation("GetApplicationMapForRoute", []interface{}{arg1})
	fake.getApplicationMapForRouteMutex.Unlock()
	if fake.GetApplicationMapForRouteStub != nil {
		return fake.GetApplicationMapForRouteStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationMapForRouteReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationMapForRouteCallCount() int {
	fake.getApplicationMapForRouteMutex.RLock()
	defer fake.getApplicationMapForRouteMutex.RUnlock()
	return len(fake.getApplicationMapForRouteArgsForCall)
}

func (fake *FakeActor) GetApplicationMapForRouteCalls(stub func(resources.Route) (map[string]resources.Application, v7action.Warnings, error)) {
	fake.getApplicationMapForRouteMutex.Lock()
	defer fake.getApplicationMapForRouteMutex.Unlock()
	fake.GetApplicationMapForRouteStub = stub
}

func (fake *FakeActor) GetApplicationMapForRouteArgsForCall(i int) resources.Route {
	fake.getApplicationMapForRouteMutex.RLock()
	defer fake.getApplicationMapForRouteMutex.RUnlock()
	argsForCall := fake.getApplicationMapForRouteArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetApplicationMapForRouteReturns(result1 map[string]resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationMapForRouteMutex.Lock()
	defer fake.getApplicationMapForRouteMutex.Unlock()
	fake.GetApplicationMapForRouteStub = nil
	fake.getApplicationMapForRouteReturns = struct {
		result1 map[string]resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationMapForRouteReturnsOnCall(i int, result1 map[string]resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationMapForRouteMutex.Lock()
	defer fake.getApplicationMapForRouteMutex.Unlock()
	fake.GetApplicationMapForRouteStub = nil
	if fake.getApplicationMapForRouteReturnsOnCall == nil {
		fake.getApplicationMapForRouteReturnsOnCall = make(map[int]struct {
			result1 map[string]resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationMapForRouteReturnsOnCall[i] = struct {
		result1 map[string]resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationPackages(arg1 string, arg2 string) ([]resources.Package, v7action.Warnings, error) {
	fake.getApplicationPackagesMutex.Lock()
	ret, specificReturn := fake.getApplicationPackagesReturnsOnCall[len(fake.getApplicationPackagesArgsForCall)]
	fake.getApplicationPackagesArgsForCall = append(fake.getApplicationPackagesArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationPackages", []interface{}{arg1, arg2})
	fake.getApplicationPackagesMutex.Unlock()
	if fake.GetApplicationPackagesStub != nil {
		return fake.GetApplicationPackagesStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationPackagesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationPackagesCallCount() int {
	fake.getApplicationPackagesMutex.RLock()
	defer fake.getApplicationPackagesMutex.RUnlock()
	return len(fake.getApplicationPackagesArgsForCall)
}

func (fake *FakeActor) GetApplicationPackagesCalls(stub func(string, string) ([]resources.Package, v7action.Warnings, error)) {
	fake.getApplicationPackagesMutex.Lock()
	defer fake.getApplicationPackagesMutex.Unlock()
	fake.GetApplicationPackagesStub = stub
}

func (fake *FakeActor) GetApplicationPackagesArgsForCall(i int) (string, string) {
	fake.getApplicationPackagesMutex.RLock()
	defer fake.getApplicationPackagesMutex.RUnlock()
	argsForCall := fake.getApplicationPackagesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetApplicationPackagesReturns(result1 []resources.Package, result2 v7action.Warnings, result3 error) {
	fake.getApplicationPackagesMutex.Lock()
	defer fake.getApplicationPackagesMutex.Unlock()
	fake.GetApplicationPackagesStub = nil
	fake.getApplicationPackagesReturns = struct {
		result1 []resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationPackagesReturnsOnCall(i int, result1 []resources.Package, result2 v7action.Warnings, result3 error) {
	fake.getApplicationPackagesMutex.Lock()
	defer fake.getApplicationPackagesMutex.Unlock()
	fake.GetApplicationPackagesStub = nil
	if fake.getApplicationPackagesReturnsOnCall == nil {
		fake.getApplicationPackagesReturnsOnCall = make(map[int]struct {
			result1 []resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationPackagesReturnsOnCall[i] = struct {
		result1 []resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpace(arg1 string, arg2 string) ([]v7action.ProcessHealthCheck, v7action.Warnings, error) {
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall[len(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall)]
	fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall = append(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetApplicationProcessHealthChecksByNameAndSpace", []interface{}{arg1, arg2})
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Unlock()
	if fake.GetApplicationProcessHealthChecksByNameAndSpaceStub != nil {
		return fake.GetApplicationProcessHealthChecksByNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationProcessHealthChecksByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceCallCount() int {
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RLock()
	defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RUnlock()
	return len(fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceCalls(stub func(string, string) ([]v7action.ProcessHealthCheck, v7action.Warnings, error)) {
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Lock()
	defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Unlock()
	fake.GetApplicationProcessHealthChecksByNameAndSpaceStub = stub
}

func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RLock()
	defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getApplicationProcessHealthChecksByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceReturns(result1 []v7action.ProcessHealthCheck, result2 v7action.Warnings, result3 error) {
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Lock()
	defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Unlock()
	fake.GetApplicationProcessHealthChecksByNameAndSpaceStub = nil
	fake.getApplicationProcessHealthChecksByNameAndSpaceReturns = struct {
		result1 []v7action.ProcessHealthCheck
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall(i int, result1 []v7action.ProcessHealthCheck, result2 v7action.Warnings, result3 error) {
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Lock()
	defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Unlock()
	fake.GetApplicationProcessHealthChecksByNameAndSpaceStub = nil
	if fake.getApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall == nil {
		fake.getApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []v7action.ProcessHealthCheck
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessHealthChecksByNameAndSpaceReturnsOnCall[i] = struct {
		result1 []v7action.ProcessHealthCheck
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationRevisionsDeployed(arg1 string) ([]resources.Revision, v7action.Warnings, error) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	ret, specificReturn := fake.getApplicationRevisionsDeployedReturnsOnCall[len(fake.getApplicationRevisionsDeployedArgsForCall)]
	fake.getApplicationRevisionsDeployedArgsForCall = append(fake.getApplicationRevisionsDeployedArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetApplicationRevisionsDeployed", []interface{}{arg1})
	fake.getApplicationRevisionsDeployedMutex.Unlock()
	if fake.GetApplicationRevisionsDeployedStub != nil {
		return fake.GetApplicationRevisionsDeployedStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationRevisionsDeployedReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationRevisionsDeployedCallCount() int {
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	return len(fake.getApplicationRevisionsDeployedArgsForCall)
}

func (fake *FakeActor) GetApplicationRevisionsDeployedCalls(stub func(string) ([]resources.Revision, v7action.Warnings, error)) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	defer fake.getApplicationRevisionsDeployedMutex.Unlock()
	fake.GetApplicationRevisionsDeployedStub = stub
}

func (fake *FakeActor) GetApplicationRevisionsDeployedArgsForCall(i int) string {
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	argsForCall := fake.getApplicationRevisionsDeployedArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetApplicationRevisionsDeployedReturns(result1 []resources.Revision, result2 v7action.Warnings, result3 error) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	defer fake.getApplicationRevisionsDeployedMutex.Unlock()
	fake.GetApplicationRevisionsDeployedStub = nil
	fake.getApplicationRevisionsDeployedReturns = struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationRevisionsDeployedReturnsOnCall(i int, result1 []resources.Revision, result2 v7action.Warnings, result3 error) {
	fake.getApplicationRevisionsDeployedMutex.Lock()
	defer fake.getApplicationRevisionsDeployedMutex.Unlock()
	fake.GetApplicationRevisionsDeployedStub = nil
	if fake.getApplicationRevisionsDeployedReturnsOnCall == nil {
		fake.getApplicationRevisionsDeployedReturnsOnCall = make(map[int]struct {
			result1 []resources.Revision
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationRevisionsDeployedReturnsOnCall[i] = struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeActor) GetApplicationRoutesCalls(stub func(string) ([]resources.Route, v7action.Warnings, error)) {
	fake.getApplicationRoutesMutex.Lock()
	defer fake.getApplicationRoutesMutex.Unlock()
	fake.GetApplicationRoutesStub = stub
}

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

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

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

func (fake *FakeActor) GetApplicationTasks(arg1 string, arg2 v7action.SortOrder) ([]resources.Task, v7action.Warnings, error) {
	fake.getApplicationTasksMutex.Lock()
	ret, specificReturn := fake.getApplicationTasksReturnsOnCall[len(fake.getApplicationTasksArgsForCall)]
	fake.getApplicationTasksArgsForCall = append(fake.getApplicationTasksArgsForCall, struct {
		arg1 string
		arg2 v7action.SortOrder
	}{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 *FakeActor) GetApplicationTasksCallCount() int {
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	return len(fake.getApplicationTasksArgsForCall)
}

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

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

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

func (fake *FakeActor) GetApplicationTasksReturnsOnCall(i int, result1 []resources.Task, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationTasksReturnsOnCall[i] = struct {
		result1 []resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationsByNamesAndSpace(arg1 []string, arg2 string) ([]resources.Application, v7action.Warnings, error) {
	var arg1Copy []string
	if arg1 != nil {
		arg1Copy = make([]string, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.getApplicationsByNamesAndSpaceMutex.Lock()
	ret, specificReturn := fake.getApplicationsByNamesAndSpaceReturnsOnCall[len(fake.getApplicationsByNamesAndSpaceArgsForCall)]
	fake.getApplicationsByNamesAndSpaceArgsForCall = append(fake.getApplicationsByNamesAndSpaceArgsForCall, struct {
		arg1 []string
		arg2 string
	}{arg1Copy, arg2})
	fake.recordInvocation("GetApplicationsByNamesAndSpace", []interface{}{arg1Copy, arg2})
	fake.getApplicationsByNamesAndSpaceMutex.Unlock()
	if fake.GetApplicationsByNamesAndSpaceStub != nil {
		return fake.GetApplicationsByNamesAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getApplicationsByNamesAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationsByNamesAndSpaceCallCount() int {
	fake.getApplicationsByNamesAndSpaceMutex.RLock()
	defer fake.getApplicationsByNamesAndSpaceMutex.RUnlock()
	return len(fake.getApplicationsByNamesAndSpaceArgsForCall)
}

func (fake *FakeActor) GetApplicationsByNamesAndSpaceCalls(stub func([]string, string) ([]resources.Application, v7action.Warnings, error)) {
	fake.getApplicationsByNamesAndSpaceMutex.Lock()
	defer fake.getApplicationsByNamesAndSpaceMutex.Unlock()
	fake.GetApplicationsByNamesAndSpaceStub = stub
}

func (fake *FakeActor) GetApplicationsByNamesAndSpaceArgsForCall(i int) ([]string, string) {
	fake.getApplicationsByNamesAndSpaceMutex.RLock()
	defer fake.getApplicationsByNamesAndSpaceMutex.RUnlock()
	argsForCall := fake.getApplicationsByNamesAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetApplicationsByNamesAndSpaceReturns(result1 []resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationsByNamesAndSpaceMutex.Lock()
	defer fake.getApplicationsByNamesAndSpaceMutex.Unlock()
	fake.GetApplicationsByNamesAndSpaceStub = nil
	fake.getApplicationsByNamesAndSpaceReturns = struct {
		result1 []resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationsByNamesAndSpaceReturnsOnCall(i int, result1 []resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationsByNamesAndSpaceMutex.Lock()
	defer fake.getApplicationsByNamesAndSpaceMutex.Unlock()
	fake.GetApplicationsByNamesAndSpaceStub = nil
	if fake.getApplicationsByNamesAndSpaceReturnsOnCall == nil {
		fake.getApplicationsByNamesAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationsByNamesAndSpaceReturnsOnCall[i] = struct {
		result1 []resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetBuildpackLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getBuildpackLabelsMutex.Lock()
	ret, specificReturn := fake.getBuildpackLabelsReturnsOnCall[len(fake.getBuildpackLabelsArgsForCall)]
	fake.getBuildpackLabelsArgsForCall = append(fake.getBuildpackLabelsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetBuildpackLabels", []interface{}{arg1, arg2})
	fake.getBuildpackLabelsMutex.Unlock()
	if fake.GetBuildpackLabelsStub != nil {
		return fake.GetBuildpackLabelsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getBuildpackLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetBuildpackLabelsCallCount() int {
	fake.getBuildpackLabelsMutex.RLock()
	defer fake.getBuildpackLabelsMutex.RUnlock()
	return len(fake.getBuildpackLabelsArgsForCall)
}

func (fake *FakeActor) GetBuildpackLabelsCalls(stub func(string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getBuildpackLabelsMutex.Lock()
	defer fake.getBuildpackLabelsMutex.Unlock()
	fake.GetBuildpackLabelsStub = stub
}

func (fake *FakeActor) GetBuildpackLabelsArgsForCall(i int) (string, string) {
	fake.getBuildpackLabelsMutex.RLock()
	defer fake.getBuildpackLabelsMutex.RUnlock()
	argsForCall := fake.getBuildpackLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetBuildpackLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getBuildpackLabelsMutex.Lock()
	defer fake.getBuildpackLabelsMutex.Unlock()
	fake.GetBuildpackLabelsStub = nil
	fake.getBuildpackLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetBuildpackLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getBuildpackLabelsMutex.Lock()
	defer fake.getBuildpackLabelsMutex.Unlock()
	fake.GetBuildpackLabelsStub = nil
	if fake.getBuildpackLabelsReturnsOnCall == nil {
		fake.getBuildpackLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getBuildpackLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetBuildpacks(arg1 string) ([]resources.Buildpack, v7action.Warnings, error) {
	fake.getBuildpacksMutex.Lock()
	ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)]
	fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct {
		arg1 string
	}{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 *FakeActor) GetBuildpacksCallCount() int {
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	return len(fake.getBuildpacksArgsForCall)
}

func (fake *FakeActor) GetBuildpacksCalls(stub func(string) ([]resources.Buildpack, v7action.Warnings, error)) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = stub
}

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

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

func (fake *FakeActor) GetBuildpacksReturnsOnCall(i int, result1 []resources.Buildpack, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.getBuildpacksReturnsOnCall[i] = struct {
		result1 []resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetCurrentUser() (configv3.User, error) {
	fake.getCurrentUserMutex.Lock()
	ret, specificReturn := fake.getCurrentUserReturnsOnCall[len(fake.getCurrentUserArgsForCall)]
	fake.getCurrentUserArgsForCall = append(fake.getCurrentUserArgsForCall, struct {
	}{})
	fake.recordInvocation("GetCurrentUser", []interface{}{})
	fake.getCurrentUserMutex.Unlock()
	if fake.GetCurrentUserStub != nil {
		return fake.GetCurrentUserStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getCurrentUserReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetCurrentUserCallCount() int {
	fake.getCurrentUserMutex.RLock()
	defer fake.getCurrentUserMutex.RUnlock()
	return len(fake.getCurrentUserArgsForCall)
}

func (fake *FakeActor) GetCurrentUserCalls(stub func() (configv3.User, error)) {
	fake.getCurrentUserMutex.Lock()
	defer fake.getCurrentUserMutex.Unlock()
	fake.GetCurrentUserStub = stub
}

func (fake *FakeActor) GetCurrentUserReturns(result1 configv3.User, result2 error) {
	fake.getCurrentUserMutex.Lock()
	defer fake.getCurrentUserMutex.Unlock()
	fake.GetCurrentUserStub = nil
	fake.getCurrentUserReturns = struct {
		result1 configv3.User
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetCurrentUserReturnsOnCall(i int, result1 configv3.User, result2 error) {
	fake.getCurrentUserMutex.Lock()
	defer fake.getCurrentUserMutex.Unlock()
	fake.GetCurrentUserStub = nil
	if fake.getCurrentUserReturnsOnCall == nil {
		fake.getCurrentUserReturnsOnCall = make(map[int]struct {
			result1 configv3.User
			result2 error
		})
	}
	fake.getCurrentUserReturnsOnCall[i] = struct {
		result1 configv3.User
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetDefaultDomain(arg1 string) (resources.Domain, v7action.Warnings, error) {
	fake.getDefaultDomainMutex.Lock()
	ret, specificReturn := fake.getDefaultDomainReturnsOnCall[len(fake.getDefaultDomainArgsForCall)]
	fake.getDefaultDomainArgsForCall = append(fake.getDefaultDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetDefaultDomain", []interface{}{arg1})
	fake.getDefaultDomainMutex.Unlock()
	if fake.GetDefaultDomainStub != nil {
		return fake.GetDefaultDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDefaultDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetDefaultDomainCallCount() int {
	fake.getDefaultDomainMutex.RLock()
	defer fake.getDefaultDomainMutex.RUnlock()
	return len(fake.getDefaultDomainArgsForCall)
}

func (fake *FakeActor) GetDefaultDomainCalls(stub func(string) (resources.Domain, v7action.Warnings, error)) {
	fake.getDefaultDomainMutex.Lock()
	defer fake.getDefaultDomainMutex.Unlock()
	fake.GetDefaultDomainStub = stub
}

func (fake *FakeActor) GetDefaultDomainArgsForCall(i int) string {
	fake.getDefaultDomainMutex.RLock()
	defer fake.getDefaultDomainMutex.RUnlock()
	argsForCall := fake.getDefaultDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetDefaultDomainReturns(result1 resources.Domain, result2 v7action.Warnings, result3 error) {
	fake.getDefaultDomainMutex.Lock()
	defer fake.getDefaultDomainMutex.Unlock()
	fake.GetDefaultDomainStub = nil
	fake.getDefaultDomainReturns = struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDefaultDomainReturnsOnCall(i int, result1 resources.Domain, result2 v7action.Warnings, result3 error) {
	fake.getDefaultDomainMutex.Lock()
	defer fake.getDefaultDomainMutex.Unlock()
	fake.GetDefaultDomainStub = nil
	if fake.getDefaultDomainReturnsOnCall == nil {
		fake.getDefaultDomainReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getDefaultDomainReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDetailedAppSummary(arg1 string, arg2 string, arg3 bool) (v7action.DetailedApplicationSummary, v7action.Warnings, error) {
	fake.getDetailedAppSummaryMutex.Lock()
	ret, specificReturn := fake.getDetailedAppSummaryReturnsOnCall[len(fake.getDetailedAppSummaryArgsForCall)]
	fake.getDetailedAppSummaryArgsForCall = append(fake.getDetailedAppSummaryArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetDetailedAppSummary", []interface{}{arg1, arg2, arg3})
	fake.getDetailedAppSummaryMutex.Unlock()
	if fake.GetDetailedAppSummaryStub != nil {
		return fake.GetDetailedAppSummaryStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDetailedAppSummaryReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetDetailedAppSummaryCallCount() int {
	fake.getDetailedAppSummaryMutex.RLock()
	defer fake.getDetailedAppSummaryMutex.RUnlock()
	return len(fake.getDetailedAppSummaryArgsForCall)
}

func (fake *FakeActor) GetDetailedAppSummaryCalls(stub func(string, string, bool) (v7action.DetailedApplicationSummary, v7action.Warnings, error)) {
	fake.getDetailedAppSummaryMutex.Lock()
	defer fake.getDetailedAppSummaryMutex.Unlock()
	fake.GetDetailedAppSummaryStub = stub
}

func (fake *FakeActor) GetDetailedAppSummaryArgsForCall(i int) (string, string, bool) {
	fake.getDetailedAppSummaryMutex.RLock()
	defer fake.getDetailedAppSummaryMutex.RUnlock()
	argsForCall := fake.getDetailedAppSummaryArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetDetailedAppSummaryReturns(result1 v7action.DetailedApplicationSummary, result2 v7action.Warnings, result3 error) {
	fake.getDetailedAppSummaryMutex.Lock()
	defer fake.getDetailedAppSummaryMutex.Unlock()
	fake.GetDetailedAppSummaryStub = nil
	fake.getDetailedAppSummaryReturns = struct {
		result1 v7action.DetailedApplicationSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDetailedAppSummaryReturnsOnCall(i int, result1 v7action.DetailedApplicationSummary, result2 v7action.Warnings, result3 error) {
	fake.getDetailedAppSummaryMutex.Lock()
	defer fake.getDetailedAppSummaryMutex.Unlock()
	fake.GetDetailedAppSummaryStub = nil
	if fake.getDetailedAppSummaryReturnsOnCall == nil {
		fake.getDetailedAppSummaryReturnsOnCall = make(map[int]struct {
			result1 v7action.DetailedApplicationSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getDetailedAppSummaryReturnsOnCall[i] = struct {
		result1 v7action.DetailedApplicationSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDomain(arg1 string) (resources.Domain, v7action.Warnings, error) {
	fake.getDomainMutex.Lock()
	ret, specificReturn := fake.getDomainReturnsOnCall[len(fake.getDomainArgsForCall)]
	fake.getDomainArgsForCall = append(fake.getDomainArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetDomain", []interface{}{arg1})
	fake.getDomainMutex.Unlock()
	if fake.GetDomainStub != nil {
		return fake.GetDomainStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDomainReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetDomainCallCount() int {
	fake.getDomainMutex.RLock()
	defer fake.getDomainMutex.RUnlock()
	return len(fake.getDomainArgsForCall)
}

func (fake *FakeActor) GetDomainCalls(stub func(string) (resources.Domain, v7action.Warnings, error)) {
	fake.getDomainMutex.Lock()
	defer fake.getDomainMutex.Unlock()
	fake.GetDomainStub = stub
}

func (fake *FakeActor) GetDomainArgsForCall(i int) string {
	fake.getDomainMutex.RLock()
	defer fake.getDomainMutex.RUnlock()
	argsForCall := fake.getDomainArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetDomainReturns(result1 resources.Domain, result2 v7action.Warnings, result3 error) {
	fake.getDomainMutex.Lock()
	defer fake.getDomainMutex.Unlock()
	fake.GetDomainStub = nil
	fake.getDomainReturns = struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDomainReturnsOnCall(i int, result1 resources.Domain, result2 v7action.Warnings, result3 error) {
	fake.getDomainMutex.Lock()
	defer fake.getDomainMutex.Unlock()
	fake.GetDomainStub = nil
	if fake.getDomainReturnsOnCall == nil {
		fake.getDomainReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getDomainReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDomainByName(arg1 string) (resources.Domain, v7action.Warnings, error) {
	fake.getDomainByNameMutex.Lock()
	ret, specificReturn := fake.getDomainByNameReturnsOnCall[len(fake.getDomainByNameArgsForCall)]
	fake.getDomainByNameArgsForCall = append(fake.getDomainByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetDomainByName", []interface{}{arg1})
	fake.getDomainByNameMutex.Unlock()
	if fake.GetDomainByNameStub != nil {
		return fake.GetDomainByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDomainByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetDomainByNameCallCount() int {
	fake.getDomainByNameMutex.RLock()
	defer fake.getDomainByNameMutex.RUnlock()
	return len(fake.getDomainByNameArgsForCall)
}

func (fake *FakeActor) GetDomainByNameCalls(stub func(string) (resources.Domain, v7action.Warnings, error)) {
	fake.getDomainByNameMutex.Lock()
	defer fake.getDomainByNameMutex.Unlock()
	fake.GetDomainByNameStub = stub
}

func (fake *FakeActor) GetDomainByNameArgsForCall(i int) string {
	fake.getDomainByNameMutex.RLock()
	defer fake.getDomainByNameMutex.RUnlock()
	argsForCall := fake.getDomainByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetDomainByNameReturns(result1 resources.Domain, result2 v7action.Warnings, result3 error) {
	fake.getDomainByNameMutex.Lock()
	defer fake.getDomainByNameMutex.Unlock()
	fake.GetDomainByNameStub = nil
	fake.getDomainByNameReturns = struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDomainByNameReturnsOnCall(i int, result1 resources.Domain, result2 v7action.Warnings, result3 error) {
	fake.getDomainByNameMutex.Lock()
	defer fake.getDomainByNameMutex.Unlock()
	fake.GetDomainByNameStub = nil
	if fake.getDomainByNameReturnsOnCall == nil {
		fake.getDomainByNameReturnsOnCall = make(map[int]struct {
			result1 resources.Domain
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getDomainByNameReturnsOnCall[i] = struct {
		result1 resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDomainLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getDomainLabelsMutex.Lock()
	ret, specificReturn := fake.getDomainLabelsReturnsOnCall[len(fake.getDomainLabelsArgsForCall)]
	fake.getDomainLabelsArgsForCall = append(fake.getDomainLabelsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetDomainLabels", []interface{}{arg1})
	fake.getDomainLabelsMutex.Unlock()
	if fake.GetDomainLabelsStub != nil {
		return fake.GetDomainLabelsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getDomainLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetDomainLabelsCallCount() int {
	fake.getDomainLabelsMutex.RLock()
	defer fake.getDomainLabelsMutex.RUnlock()
	return len(fake.getDomainLabelsArgsForCall)
}

func (fake *FakeActor) GetDomainLabelsCalls(stub func(string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getDomainLabelsMutex.Lock()
	defer fake.getDomainLabelsMutex.Unlock()
	fake.GetDomainLabelsStub = stub
}

func (fake *FakeActor) GetDomainLabelsArgsForCall(i int) string {
	fake.getDomainLabelsMutex.RLock()
	defer fake.getDomainLabelsMutex.RUnlock()
	argsForCall := fake.getDomainLabelsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetDomainLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getDomainLabelsMutex.Lock()
	defer fake.getDomainLabelsMutex.Unlock()
	fake.GetDomainLabelsStub = nil
	fake.getDomainLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetDomainLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getDomainLabelsMutex.Lock()
	defer fake.getDomainLabelsMutex.Unlock()
	fake.GetDomainLabelsStub = nil
	if fake.getDomainLabelsReturnsOnCall == nil {
		fake.getDomainLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getDomainLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetEffectiveIsolationSegmentBySpace(arg1 string, arg2 string) (resources.IsolationSegment, v7action.Warnings, error) {
	fake.getEffectiveIsolationSegmentBySpaceMutex.Lock()
	ret, specificReturn := fake.getEffectiveIsolationSegmentBySpaceReturnsOnCall[len(fake.getEffectiveIsolationSegmentBySpaceArgsForCall)]
	fake.getEffectiveIsolationSegmentBySpaceArgsForCall = append(fake.getEffectiveIsolationSegmentBySpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetEffectiveIsolationSegmentBySpace", []interface{}{arg1, arg2})
	fake.getEffectiveIsolationSegmentBySpaceMutex.Unlock()
	if fake.GetEffectiveIsolationSegmentBySpaceStub != nil {
		return fake.GetEffectiveIsolationSegmentBySpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getEffectiveIsolationSegmentBySpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceCallCount() int {
	fake.getEffectiveIsolationSegmentBySpaceMutex.RLock()
	defer fake.getEffectiveIsolationSegmentBySpaceMutex.RUnlock()
	return len(fake.getEffectiveIsolationSegmentBySpaceArgsForCall)
}

func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceCalls(stub func(string, string) (resources.IsolationSegment, v7action.Warnings, error)) {
	fake.getEffectiveIsolationSegmentBySpaceMutex.Lock()
	defer fake.getEffectiveIsolationSegmentBySpaceMutex.Unlock()
	fake.GetEffectiveIsolationSegmentBySpaceStub = stub
}

func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceArgsForCall(i int) (string, string) {
	fake.getEffectiveIsolationSegmentBySpaceMutex.RLock()
	defer fake.getEffectiveIsolationSegmentBySpaceMutex.RUnlock()
	argsForCall := fake.getEffectiveIsolationSegmentBySpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceReturns(result1 resources.IsolationSegment, result2 v7action.Warnings, result3 error) {
	fake.getEffectiveIsolationSegmentBySpaceMutex.Lock()
	defer fake.getEffectiveIsolationSegmentBySpaceMutex.Unlock()
	fake.GetEffectiveIsolationSegmentBySpaceStub = nil
	fake.getEffectiveIsolationSegmentBySpaceReturns = struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetEffectiveIsolationSegmentBySpaceReturnsOnCall(i int, result1 resources.IsolationSegment, result2 v7action.Warnings, result3 error) {
	fake.getEffectiveIsolationSegmentBySpaceMutex.Lock()
	defer fake.getEffectiveIsolationSegmentBySpaceMutex.Unlock()
	fake.GetEffectiveIsolationSegmentBySpaceStub = nil
	if fake.getEffectiveIsolationSegmentBySpaceReturnsOnCall == nil {
		fake.getEffectiveIsolationSegmentBySpaceReturnsOnCall = make(map[int]struct {
			result1 resources.IsolationSegment
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getEffectiveIsolationSegmentBySpaceReturnsOnCall[i] = struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetEnvironmentVariableGroup(arg1 constanta.EnvironmentVariableGroupName) (v7action.EnvironmentVariableGroup, v7action.Warnings, error) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	ret, specificReturn := fake.getEnvironmentVariableGroupReturnsOnCall[len(fake.getEnvironmentVariableGroupArgsForCall)]
	fake.getEnvironmentVariableGroupArgsForCall = append(fake.getEnvironmentVariableGroupArgsForCall, struct {
		arg1 constanta.EnvironmentVariableGroupName
	}{arg1})
	fake.recordInvocation("GetEnvironmentVariableGroup", []interface{}{arg1})
	fake.getEnvironmentVariableGroupMutex.Unlock()
	if fake.GetEnvironmentVariableGroupStub != nil {
		return fake.GetEnvironmentVariableGroupStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getEnvironmentVariableGroupReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetEnvironmentVariableGroupCallCount() int {
	fake.getEnvironmentVariableGroupMutex.RLock()
	defer fake.getEnvironmentVariableGroupMutex.RUnlock()
	return len(fake.getEnvironmentVariableGroupArgsForCall)
}

func (fake *FakeActor) GetEnvironmentVariableGroupCalls(stub func(constanta.EnvironmentVariableGroupName) (v7action.EnvironmentVariableGroup, v7action.Warnings, error)) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	defer fake.getEnvironmentVariableGroupMutex.Unlock()
	fake.GetEnvironmentVariableGroupStub = stub
}

func (fake *FakeActor) GetEnvironmentVariableGroupArgsForCall(i int) constanta.EnvironmentVariableGroupName {
	fake.getEnvironmentVariableGroupMutex.RLock()
	defer fake.getEnvironmentVariableGroupMutex.RUnlock()
	argsForCall := fake.getEnvironmentVariableGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetEnvironmentVariableGroupReturns(result1 v7action.EnvironmentVariableGroup, result2 v7action.Warnings, result3 error) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	defer fake.getEnvironmentVariableGroupMutex.Unlock()
	fake.GetEnvironmentVariableGroupStub = nil
	fake.getEnvironmentVariableGroupReturns = struct {
		result1 v7action.EnvironmentVariableGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetEnvironmentVariableGroupReturnsOnCall(i int, result1 v7action.EnvironmentVariableGroup, result2 v7action.Warnings, result3 error) {
	fake.getEnvironmentVariableGroupMutex.Lock()
	defer fake.getEnvironmentVariableGroupMutex.Unlock()
	fake.GetEnvironmentVariableGroupStub = nil
	if fake.getEnvironmentVariableGroupReturnsOnCall == nil {
		fake.getEnvironmentVariableGroupReturnsOnCall = make(map[int]struct {
			result1 v7action.EnvironmentVariableGroup
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getEnvironmentVariableGroupReturnsOnCall[i] = struct {
		result1 v7action.EnvironmentVariableGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpace(arg1 string, arg2 string) (v7action.EnvironmentVariableGroups, v7action.Warnings, error) {
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall[len(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall)]
	fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall = append(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetEnvironmentVariablesByApplicationNameAndSpace", []interface{}{arg1, arg2})
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Unlock()
	if fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub != nil {
		return fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getEnvironmentVariablesByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceCallCount() int {
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RLock()
	defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceCalls(stub func(string, string) (v7action.EnvironmentVariableGroups, v7action.Warnings, error)) {
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Lock()
	defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Unlock()
	fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RLock()
	defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getEnvironmentVariablesByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceReturns(result1 v7action.EnvironmentVariableGroups, result2 v7action.Warnings, result3 error) {
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Lock()
	defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Unlock()
	fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub = nil
	fake.getEnvironmentVariablesByApplicationNameAndSpaceReturns = struct {
		result1 v7action.EnvironmentVariableGroups
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall(i int, result1 v7action.EnvironmentVariableGroups, result2 v7action.Warnings, result3 error) {
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Lock()
	defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Unlock()
	fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub = nil
	if fake.getEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.getEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 v7action.EnvironmentVariableGroups
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getEnvironmentVariablesByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 v7action.EnvironmentVariableGroups
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetFeatureFlagByName(arg1 string) (resources.FeatureFlag, v7action.Warnings, error) {
	fake.getFeatureFlagByNameMutex.Lock()
	ret, specificReturn := fake.getFeatureFlagByNameReturnsOnCall[len(fake.getFeatureFlagByNameArgsForCall)]
	fake.getFeatureFlagByNameArgsForCall = append(fake.getFeatureFlagByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetFeatureFlagByName", []interface{}{arg1})
	fake.getFeatureFlagByNameMutex.Unlock()
	if fake.GetFeatureFlagByNameStub != nil {
		return fake.GetFeatureFlagByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getFeatureFlagByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetFeatureFlagByNameCallCount() int {
	fake.getFeatureFlagByNameMutex.RLock()
	defer fake.getFeatureFlagByNameMutex.RUnlock()
	return len(fake.getFeatureFlagByNameArgsForCall)
}

func (fake *FakeActor) GetFeatureFlagByNameCalls(stub func(string) (resources.FeatureFlag, v7action.Warnings, error)) {
	fake.getFeatureFlagByNameMutex.Lock()
	defer fake.getFeatureFlagByNameMutex.Unlock()
	fake.GetFeatureFlagByNameStub = stub
}

func (fake *FakeActor) GetFeatureFlagByNameArgsForCall(i int) string {
	fake.getFeatureFlagByNameMutex.RLock()
	defer fake.getFeatureFlagByNameMutex.RUnlock()
	argsForCall := fake.getFeatureFlagByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetFeatureFlagByNameReturns(result1 resources.FeatureFlag, result2 v7action.Warnings, result3 error) {
	fake.getFeatureFlagByNameMutex.Lock()
	defer fake.getFeatureFlagByNameMutex.Unlock()
	fake.GetFeatureFlagByNameStub = nil
	fake.getFeatureFlagByNameReturns = struct {
		result1 resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetFeatureFlagByNameReturnsOnCall(i int, result1 resources.FeatureFlag, result2 v7action.Warnings, result3 error) {
	fake.getFeatureFlagByNameMutex.Lock()
	defer fake.getFeatureFlagByNameMutex.Unlock()
	fake.GetFeatureFlagByNameStub = nil
	if fake.getFeatureFlagByNameReturnsOnCall == nil {
		fake.getFeatureFlagByNameReturnsOnCall = make(map[int]struct {
			result1 resources.FeatureFlag
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getFeatureFlagByNameReturnsOnCall[i] = struct {
		result1 resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetFeatureFlags() ([]resources.FeatureFlag, v7action.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 *FakeActor) GetFeatureFlagsCallCount() int {
	fake.getFeatureFlagsMutex.RLock()
	defer fake.getFeatureFlagsMutex.RUnlock()
	return len(fake.getFeatureFlagsArgsForCall)
}

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

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

func (fake *FakeActor) GetFeatureFlagsReturnsOnCall(i int, result1 []resources.FeatureFlag, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.getFeatureFlagsReturnsOnCall[i] = struct {
		result1 []resources.FeatureFlag
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetGlobalRunningSecurityGroups() ([]resources.SecurityGroup, v7action.Warnings, error) {
	fake.getGlobalRunningSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getGlobalRunningSecurityGroupsReturnsOnCall[len(fake.getGlobalRunningSecurityGroupsArgsForCall)]
	fake.getGlobalRunningSecurityGroupsArgsForCall = append(fake.getGlobalRunningSecurityGroupsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetGlobalRunningSecurityGroups", []interface{}{})
	fake.getGlobalRunningSecurityGroupsMutex.Unlock()
	if fake.GetGlobalRunningSecurityGroupsStub != nil {
		return fake.GetGlobalRunningSecurityGroupsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getGlobalRunningSecurityGroupsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetGlobalRunningSecurityGroupsCallCount() int {
	fake.getGlobalRunningSecurityGroupsMutex.RLock()
	defer fake.getGlobalRunningSecurityGroupsMutex.RUnlock()
	return len(fake.getGlobalRunningSecurityGroupsArgsForCall)
}

func (fake *FakeActor) GetGlobalRunningSecurityGroupsCalls(stub func() ([]resources.SecurityGroup, v7action.Warnings, error)) {
	fake.getGlobalRunningSecurityGroupsMutex.Lock()
	defer fake.getGlobalRunningSecurityGroupsMutex.Unlock()
	fake.GetGlobalRunningSecurityGroupsStub = stub
}

func (fake *FakeActor) GetGlobalRunningSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 v7action.Warnings, result3 error) {
	fake.getGlobalRunningSecurityGroupsMutex.Lock()
	defer fake.getGlobalRunningSecurityGroupsMutex.Unlock()
	fake.GetGlobalRunningSecurityGroupsStub = nil
	fake.getGlobalRunningSecurityGroupsReturns = struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetGlobalRunningSecurityGroupsReturnsOnCall(i int, result1 []resources.SecurityGroup, result2 v7action.Warnings, result3 error) {
	fake.getGlobalRunningSecurityGroupsMutex.Lock()
	defer fake.getGlobalRunningSecurityGroupsMutex.Unlock()
	fake.GetGlobalRunningSecurityGroupsStub = nil
	if fake.getGlobalRunningSecurityGroupsReturnsOnCall == nil {
		fake.getGlobalRunningSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []resources.SecurityGroup
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getGlobalRunningSecurityGroupsReturnsOnCall[i] = struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetGlobalStagingSecurityGroups() ([]resources.SecurityGroup, v7action.Warnings, error) {
	fake.getGlobalStagingSecurityGroupsMutex.Lock()
	ret, specificReturn := fake.getGlobalStagingSecurityGroupsReturnsOnCall[len(fake.getGlobalStagingSecurityGroupsArgsForCall)]
	fake.getGlobalStagingSecurityGroupsArgsForCall = append(fake.getGlobalStagingSecurityGroupsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetGlobalStagingSecurityGroups", []interface{}{})
	fake.getGlobalStagingSecurityGroupsMutex.Unlock()
	if fake.GetGlobalStagingSecurityGroupsStub != nil {
		return fake.GetGlobalStagingSecurityGroupsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getGlobalStagingSecurityGroupsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetGlobalStagingSecurityGroupsCallCount() int {
	fake.getGlobalStagingSecurityGroupsMutex.RLock()
	defer fake.getGlobalStagingSecurityGroupsMutex.RUnlock()
	return len(fake.getGlobalStagingSecurityGroupsArgsForCall)
}

func (fake *FakeActor) GetGlobalStagingSecurityGroupsCalls(stub func() ([]resources.SecurityGroup, v7action.Warnings, error)) {
	fake.getGlobalStagingSecurityGroupsMutex.Lock()
	defer fake.getGlobalStagingSecurityGroupsMutex.Unlock()
	fake.GetGlobalStagingSecurityGroupsStub = stub
}

func (fake *FakeActor) GetGlobalStagingSecurityGroupsReturns(result1 []resources.SecurityGroup, result2 v7action.Warnings, result3 error) {
	fake.getGlobalStagingSecurityGroupsMutex.Lock()
	defer fake.getGlobalStagingSecurityGroupsMutex.Unlock()
	fake.GetGlobalStagingSecurityGroupsStub = nil
	fake.getGlobalStagingSecurityGroupsReturns = struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetGlobalStagingSecurityGroupsReturnsOnCall(i int, result1 []resources.SecurityGroup, result2 v7action.Warnings, result3 error) {
	fake.getGlobalStagingSecurityGroupsMutex.Lock()
	defer fake.getGlobalStagingSecurityGroupsMutex.Unlock()
	fake.GetGlobalStagingSecurityGroupsStub = nil
	if fake.getGlobalStagingSecurityGroupsReturnsOnCall == nil {
		fake.getGlobalStagingSecurityGroupsReturnsOnCall = make(map[int]struct {
			result1 []resources.SecurityGroup
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getGlobalStagingSecurityGroupsReturnsOnCall[i] = struct {
		result1 []resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetIsolationSegmentByName(arg1 string) (resources.IsolationSegment, v7action.Warnings, error) {
	fake.getIsolationSegmentByNameMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentByNameReturnsOnCall[len(fake.getIsolationSegmentByNameArgsForCall)]
	fake.getIsolationSegmentByNameArgsForCall = append(fake.getIsolationSegmentByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetIsolationSegmentByName", []interface{}{arg1})
	fake.getIsolationSegmentByNameMutex.Unlock()
	if fake.GetIsolationSegmentByNameStub != nil {
		return fake.GetIsolationSegmentByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetIsolationSegmentByNameCallCount() int {
	fake.getIsolationSegmentByNameMutex.RLock()
	defer fake.getIsolationSegmentByNameMutex.RUnlock()
	return len(fake.getIsolationSegmentByNameArgsForCall)
}

func (fake *FakeActor) GetIsolationSegmentByNameCalls(stub func(string) (resources.IsolationSegment, v7action.Warnings, error)) {
	fake.getIsolationSegmentByNameMutex.Lock()
	defer fake.getIsolationSegmentByNameMutex.Unlock()
	fake.GetIsolationSegmentByNameStub = stub
}

func (fake *FakeActor) GetIsolationSegmentByNameArgsForCall(i int) string {
	fake.getIsolationSegmentByNameMutex.RLock()
	defer fake.getIsolationSegmentByNameMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetIsolationSegmentByNameReturns(result1 resources.IsolationSegment, result2 v7action.Warnings, result3 error) {
	fake.getIsolationSegmentByNameMutex.Lock()
	defer fake.getIsolationSegmentByNameMutex.Unlock()
	fake.GetIsolationSegmentByNameStub = nil
	fake.getIsolationSegmentByNameReturns = struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetIsolationSegmentByNameReturnsOnCall(i int, result1 resources.IsolationSegment, result2 v7action.Warnings, result3 error) {
	fake.getIsolationSegmentByNameMutex.Lock()
	defer fake.getIsolationSegmentByNameMutex.Unlock()
	fake.GetIsolationSegmentByNameStub = nil
	if fake.getIsolationSegmentByNameReturnsOnCall == nil {
		fake.getIsolationSegmentByNameReturnsOnCall = make(map[int]struct {
			result1 resources.IsolationSegment
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentByNameReturnsOnCall[i] = struct {
		result1 resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetIsolationSegmentSummaries() ([]v7action.IsolationSegmentSummary, v7action.Warnings, error) {
	fake.getIsolationSegmentSummariesMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentSummariesReturnsOnCall[len(fake.getIsolationSegmentSummariesArgsForCall)]
	fake.getIsolationSegmentSummariesArgsForCall = append(fake.getIsolationSegmentSummariesArgsForCall, struct {
	}{})
	fake.recordInvocation("GetIsolationSegmentSummaries", []interface{}{})
	fake.getIsolationSegmentSummariesMutex.Unlock()
	if fake.GetIsolationSegmentSummariesStub != nil {
		return fake.GetIsolationSegmentSummariesStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentSummariesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetIsolationSegmentSummariesCallCount() int {
	fake.getIsolationSegmentSummariesMutex.RLock()
	defer fake.getIsolationSegmentSummariesMutex.RUnlock()
	return len(fake.getIsolationSegmentSummariesArgsForCall)
}

func (fake *FakeActor) GetIsolationSegmentSummariesCalls(stub func() ([]v7action.IsolationSegmentSummary, v7action.Warnings, error)) {
	fake.getIsolationSegmentSummariesMutex.Lock()
	defer fake.getIsolationSegmentSummariesMutex.Unlock()
	fake.GetIsolationSegmentSummariesStub = stub
}

func (fake *FakeActor) GetIsolationSegmentSummariesReturns(result1 []v7action.IsolationSegmentSummary, result2 v7action.Warnings, result3 error) {
	fake.getIsolationSegmentSummariesMutex.Lock()
	defer fake.getIsolationSegmentSummariesMutex.Unlock()
	fake.GetIsolationSegmentSummariesStub = nil
	fake.getIsolationSegmentSummariesReturns = struct {
		result1 []v7action.IsolationSegmentSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetIsolationSegmentSummariesReturnsOnCall(i int, result1 []v7action.IsolationSegmentSummary, result2 v7action.Warnings, result3 error) {
	fake.getIsolationSegmentSummariesMutex.Lock()
	defer fake.getIsolationSegmentSummariesMutex.Unlock()
	fake.GetIsolationSegmentSummariesStub = nil
	if fake.getIsolationSegmentSummariesReturnsOnCall == nil {
		fake.getIsolationSegmentSummariesReturnsOnCall = make(map[int]struct {
			result1 []v7action.IsolationSegmentSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentSummariesReturnsOnCall[i] = struct {
		result1 []v7action.IsolationSegmentSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetIsolationSegmentsByOrganization(arg1 string) ([]resources.IsolationSegment, v7action.Warnings, error) {
	fake.getIsolationSegmentsByOrganizationMutex.Lock()
	ret, specificReturn := fake.getIsolationSegmentsByOrganizationReturnsOnCall[len(fake.getIsolationSegmentsByOrganizationArgsForCall)]
	fake.getIsolationSegmentsByOrganizationArgsForCall = append(fake.getIsolationSegmentsByOrganizationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetIsolationSegmentsByOrganization", []interface{}{arg1})
	fake.getIsolationSegmentsByOrganizationMutex.Unlock()
	if fake.GetIsolationSegmentsByOrganizationStub != nil {
		return fake.GetIsolationSegmentsByOrganizationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getIsolationSegmentsByOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetIsolationSegmentsByOrganizationCallCount() int {
	fake.getIsolationSegmentsByOrganizationMutex.RLock()
	defer fake.getIsolationSegmentsByOrganizationMutex.RUnlock()
	return len(fake.getIsolationSegmentsByOrganizationArgsForCall)
}

func (fake *FakeActor) GetIsolationSegmentsByOrganizationCalls(stub func(string) ([]resources.IsolationSegment, v7action.Warnings, error)) {
	fake.getIsolationSegmentsByOrganizationMutex.Lock()
	defer fake.getIsolationSegmentsByOrganizationMutex.Unlock()
	fake.GetIsolationSegmentsByOrganizationStub = stub
}

func (fake *FakeActor) GetIsolationSegmentsByOrganizationArgsForCall(i int) string {
	fake.getIsolationSegmentsByOrganizationMutex.RLock()
	defer fake.getIsolationSegmentsByOrganizationMutex.RUnlock()
	argsForCall := fake.getIsolationSegmentsByOrganizationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetIsolationSegmentsByOrganizationReturns(result1 []resources.IsolationSegment, result2 v7action.Warnings, result3 error) {
	fake.getIsolationSegmentsByOrganizationMutex.Lock()
	defer fake.getIsolationSegmentsByOrganizationMutex.Unlock()
	fake.GetIsolationSegmentsByOrganizationStub = nil
	fake.getIsolationSegmentsByOrganizationReturns = struct {
		result1 []resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetIsolationSegmentsByOrganizationReturnsOnCall(i int, result1 []resources.IsolationSegment, result2 v7action.Warnings, result3 error) {
	fake.getIsolationSegmentsByOrganizationMutex.Lock()
	defer fake.getIsolationSegmentsByOrganizationMutex.Unlock()
	fake.GetIsolationSegmentsByOrganizationStub = nil
	if fake.getIsolationSegmentsByOrganizationReturnsOnCall == nil {
		fake.getIsolationSegmentsByOrganizationReturnsOnCall = make(map[int]struct {
			result1 []resources.IsolationSegment
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getIsolationSegmentsByOrganizationReturnsOnCall[i] = struct {
		result1 []resources.IsolationSegment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetLatestActiveDeploymentForApp(arg1 string) (resources.Deployment, v7action.Warnings, error) {
	fake.getLatestActiveDeploymentForAppMutex.Lock()
	ret, specificReturn := fake.getLatestActiveDeploymentForAppReturnsOnCall[len(fake.getLatestActiveDeploymentForAppArgsForCall)]
	fake.getLatestActiveDeploymentForAppArgsForCall = append(fake.getLatestActiveDeploymentForAppArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetLatestActiveDeploymentForApp", []interface{}{arg1})
	fake.getLatestActiveDeploymentForAppMutex.Unlock()
	if fake.GetLatestActiveDeploymentForAppStub != nil {
		return fake.GetLatestActiveDeploymentForAppStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getLatestActiveDeploymentForAppReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetLatestActiveDeploymentForAppCallCount() int {
	fake.getLatestActiveDeploymentForAppMutex.RLock()
	defer fake.getLatestActiveDeploymentForAppMutex.RUnlock()
	return len(fake.getLatestActiveDeploymentForAppArgsForCall)
}

func (fake *FakeActor) GetLatestActiveDeploymentForAppCalls(stub func(string) (resources.Deployment, v7action.Warnings, error)) {
	fake.getLatestActiveDeploymentForAppMutex.Lock()
	defer fake.getLatestActiveDeploymentForAppMutex.Unlock()
	fake.GetLatestActiveDeploymentForAppStub = stub
}

func (fake *FakeActor) GetLatestActiveDeploymentForAppArgsForCall(i int) string {
	fake.getLatestActiveDeploymentForAppMutex.RLock()
	defer fake.getLatestActiveDeploymentForAppMutex.RUnlock()
	argsForCall := fake.getLatestActiveDeploymentForAppArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetLatestActiveDeploymentForAppReturns(result1 resources.Deployment, result2 v7action.Warnings, result3 error) {
	fake.getLatestActiveDeploymentForAppMutex.Lock()
	defer fake.getLatestActiveDeploymentForAppMutex.Unlock()
	fake.GetLatestActiveDeploymentForAppStub = nil
	fake.getLatestActiveDeploymentForAppReturns = struct {
		result1 resources.Deployment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetLatestActiveDeploymentForAppReturnsOnCall(i int, result1 resources.Deployment, result2 v7action.Warnings, result3 error) {
	fake.getLatestActiveDeploymentForAppMutex.Lock()
	defer fake.getLatestActiveDeploymentForAppMutex.Unlock()
	fake.GetLatestActiveDeploymentForAppStub = nil
	if fake.getLatestActiveDeploymentForAppReturnsOnCall == nil {
		fake.getLatestActiveDeploymentForAppReturnsOnCall = make(map[int]struct {
			result1 resources.Deployment
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getLatestActiveDeploymentForAppReturnsOnCall[i] = struct {
		result1 resources.Deployment
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetLoginPrompts() (map[string]coreconfig.AuthPrompt, error) {
	fake.getLoginPromptsMutex.Lock()
	ret, specificReturn := fake.getLoginPromptsReturnsOnCall[len(fake.getLoginPromptsArgsForCall)]
	fake.getLoginPromptsArgsForCall = append(fake.getLoginPromptsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetLoginPrompts", []interface{}{})
	fake.getLoginPromptsMutex.Unlock()
	if fake.GetLoginPromptsStub != nil {
		return fake.GetLoginPromptsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getLoginPromptsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetLoginPromptsCallCount() int {
	fake.getLoginPromptsMutex.RLock()
	defer fake.getLoginPromptsMutex.RUnlock()
	return len(fake.getLoginPromptsArgsForCall)
}

func (fake *FakeActor) GetLoginPromptsCalls(stub func() (map[string]coreconfig.AuthPrompt, error)) {
	fake.getLoginPromptsMutex.Lock()
	defer fake.getLoginPromptsMutex.Unlock()
	fake.GetLoginPromptsStub = stub
}

func (fake *FakeActor) GetLoginPromptsReturns(result1 map[string]coreconfig.AuthPrompt, result2 error) {
	fake.getLoginPromptsMutex.Lock()
	defer fake.getLoginPromptsMutex.Unlock()
	fake.GetLoginPromptsStub = nil
	fake.getLoginPromptsReturns = struct {
		result1 map[string]coreconfig.AuthPrompt
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetLoginPromptsReturnsOnCall(i int, result1 map[string]coreconfig.AuthPrompt, result2 error) {
	fake.getLoginPromptsMutex.Lock()
	defer fake.getLoginPromptsMutex.Unlock()
	fake.GetLoginPromptsStub = nil
	if fake.getLoginPromptsReturnsOnCall == nil {
		fake.getLoginPromptsReturnsOnCall = make(map[int]struct {
			result1 map[string]coreconfig.AuthPrompt
			result2 error
		})
	}
	fake.getLoginPromptsReturnsOnCall[i] = struct {
		result1 map[string]coreconfig.AuthPrompt
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetNewestReadyPackageForApplication(arg1 resources.Application) (resources.Package, v7action.Warnings, error) {
	fake.getNewestReadyPackageForApplicationMutex.Lock()
	ret, specificReturn := fake.getNewestReadyPackageForApplicationReturnsOnCall[len(fake.getNewestReadyPackageForApplicationArgsForCall)]
	fake.getNewestReadyPackageForApplicationArgsForCall = append(fake.getNewestReadyPackageForApplicationArgsForCall, struct {
		arg1 resources.Application
	}{arg1})
	fake.recordInvocation("GetNewestReadyPackageForApplication", []interface{}{arg1})
	fake.getNewestReadyPackageForApplicationMutex.Unlock()
	if fake.GetNewestReadyPackageForApplicationStub != nil {
		return fake.GetNewestReadyPackageForApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getNewestReadyPackageForApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetNewestReadyPackageForApplicationCallCount() int {
	fake.getNewestReadyPackageForApplicationMutex.RLock()
	defer fake.getNewestReadyPackageForApplicationMutex.RUnlock()
	return len(fake.getNewestReadyPackageForApplicationArgsForCall)
}

func (fake *FakeActor) GetNewestReadyPackageForApplicationCalls(stub func(resources.Application) (resources.Package, v7action.Warnings, error)) {
	fake.getNewestReadyPackageForApplicationMutex.Lock()
	defer fake.getNewestReadyPackageForApplicationMutex.Unlock()
	fake.GetNewestReadyPackageForApplicationStub = stub
}

func (fake *FakeActor) GetNewestReadyPackageForApplicationArgsForCall(i int) resources.Application {
	fake.getNewestReadyPackageForApplicationMutex.RLock()
	defer fake.getNewestReadyPackageForApplicationMutex.RUnlock()
	argsForCall := fake.getNewestReadyPackageForApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetNewestReadyPackageForApplicationReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.getNewestReadyPackageForApplicationMutex.Lock()
	defer fake.getNewestReadyPackageForApplicationMutex.Unlock()
	fake.GetNewestReadyPackageForApplicationStub = nil
	fake.getNewestReadyPackageForApplicationReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetNewestReadyPackageForApplicationReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.getNewestReadyPackageForApplicationMutex.Lock()
	defer fake.getNewestReadyPackageForApplicationMutex.Unlock()
	fake.GetNewestReadyPackageForApplicationStub = nil
	if fake.getNewestReadyPackageForApplicationReturnsOnCall == nil {
		fake.getNewestReadyPackageForApplicationReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getNewestReadyPackageForApplicationReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrgUsersByRoleType(arg1 string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error) {
	fake.getOrgUsersByRoleTypeMutex.Lock()
	ret, specificReturn := fake.getOrgUsersByRoleTypeReturnsOnCall[len(fake.getOrgUsersByRoleTypeArgsForCall)]
	fake.getOrgUsersByRoleTypeArgsForCall = append(fake.getOrgUsersByRoleTypeArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrgUsersByRoleType", []interface{}{arg1})
	fake.getOrgUsersByRoleTypeMutex.Unlock()
	if fake.GetOrgUsersByRoleTypeStub != nil {
		return fake.GetOrgUsersByRoleTypeStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrgUsersByRoleTypeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrgUsersByRoleTypeCallCount() int {
	fake.getOrgUsersByRoleTypeMutex.RLock()
	defer fake.getOrgUsersByRoleTypeMutex.RUnlock()
	return len(fake.getOrgUsersByRoleTypeArgsForCall)
}

func (fake *FakeActor) GetOrgUsersByRoleTypeCalls(stub func(string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error)) {
	fake.getOrgUsersByRoleTypeMutex.Lock()
	defer fake.getOrgUsersByRoleTypeMutex.Unlock()
	fake.GetOrgUsersByRoleTypeStub = stub
}

func (fake *FakeActor) GetOrgUsersByRoleTypeArgsForCall(i int) string {
	fake.getOrgUsersByRoleTypeMutex.RLock()
	defer fake.getOrgUsersByRoleTypeMutex.RUnlock()
	argsForCall := fake.getOrgUsersByRoleTypeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetOrgUsersByRoleTypeReturns(result1 map[constanta.RoleType][]resources.User, result2 v7action.Warnings, result3 error) {
	fake.getOrgUsersByRoleTypeMutex.Lock()
	defer fake.getOrgUsersByRoleTypeMutex.Unlock()
	fake.GetOrgUsersByRoleTypeStub = nil
	fake.getOrgUsersByRoleTypeReturns = struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrgUsersByRoleTypeReturnsOnCall(i int, result1 map[constanta.RoleType][]resources.User, result2 v7action.Warnings, result3 error) {
	fake.getOrgUsersByRoleTypeMutex.Lock()
	defer fake.getOrgUsersByRoleTypeMutex.Unlock()
	fake.GetOrgUsersByRoleTypeStub = nil
	if fake.getOrgUsersByRoleTypeReturnsOnCall == nil {
		fake.getOrgUsersByRoleTypeReturnsOnCall = make(map[int]struct {
			result1 map[constanta.RoleType][]resources.User
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrgUsersByRoleTypeReturnsOnCall[i] = struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationByName(arg1 string) (resources.Organization, v7action.Warnings, error) {
	fake.getOrganizationByNameMutex.Lock()
	ret, specificReturn := fake.getOrganizationByNameReturnsOnCall[len(fake.getOrganizationByNameArgsForCall)]
	fake.getOrganizationByNameArgsForCall = append(fake.getOrganizationByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationByName", []interface{}{arg1})
	fake.getOrganizationByNameMutex.Unlock()
	if fake.GetOrganizationByNameStub != nil {
		return fake.GetOrganizationByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrganizationByNameCallCount() int {
	fake.getOrganizationByNameMutex.RLock()
	defer fake.getOrganizationByNameMutex.RUnlock()
	return len(fake.getOrganizationByNameArgsForCall)
}

func (fake *FakeActor) GetOrganizationByNameCalls(stub func(string) (resources.Organization, v7action.Warnings, error)) {
	fake.getOrganizationByNameMutex.Lock()
	defer fake.getOrganizationByNameMutex.Unlock()
	fake.GetOrganizationByNameStub = stub
}

func (fake *FakeActor) GetOrganizationByNameArgsForCall(i int) string {
	fake.getOrganizationByNameMutex.RLock()
	defer fake.getOrganizationByNameMutex.RUnlock()
	argsForCall := fake.getOrganizationByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetOrganizationByNameReturns(result1 resources.Organization, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationByNameMutex.Lock()
	defer fake.getOrganizationByNameMutex.Unlock()
	fake.GetOrganizationByNameStub = nil
	fake.getOrganizationByNameReturns = struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationByNameReturnsOnCall(i int, result1 resources.Organization, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationByNameMutex.Lock()
	defer fake.getOrganizationByNameMutex.Unlock()
	fake.GetOrganizationByNameStub = nil
	if fake.getOrganizationByNameReturnsOnCall == nil {
		fake.getOrganizationByNameReturnsOnCall = make(map[int]struct {
			result1 resources.Organization
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationByNameReturnsOnCall[i] = struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationDomains(arg1 string, arg2 string) ([]resources.Domain, v7action.Warnings, error) {
	fake.getOrganizationDomainsMutex.Lock()
	ret, specificReturn := fake.getOrganizationDomainsReturnsOnCall[len(fake.getOrganizationDomainsArgsForCall)]
	fake.getOrganizationDomainsArgsForCall = append(fake.getOrganizationDomainsArgsForCall, struct {
		arg1 string
		arg2 string
	}{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 *FakeActor) GetOrganizationDomainsCallCount() int {
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	return len(fake.getOrganizationDomainsArgsForCall)
}

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

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

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

func (fake *FakeActor) GetOrganizationDomainsReturnsOnCall(i int, result1 []resources.Domain, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationDomainsReturnsOnCall[i] = struct {
		result1 []resources.Domain
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getOrganizationLabelsMutex.Lock()
	ret, specificReturn := fake.getOrganizationLabelsReturnsOnCall[len(fake.getOrganizationLabelsArgsForCall)]
	fake.getOrganizationLabelsArgsForCall = append(fake.getOrganizationLabelsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationLabels", []interface{}{arg1})
	fake.getOrganizationLabelsMutex.Unlock()
	if fake.GetOrganizationLabelsStub != nil {
		return fake.GetOrganizationLabelsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrganizationLabelsCallCount() int {
	fake.getOrganizationLabelsMutex.RLock()
	defer fake.getOrganizationLabelsMutex.RUnlock()
	return len(fake.getOrganizationLabelsArgsForCall)
}

func (fake *FakeActor) GetOrganizationLabelsCalls(stub func(string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getOrganizationLabelsMutex.Lock()
	defer fake.getOrganizationLabelsMutex.Unlock()
	fake.GetOrganizationLabelsStub = stub
}

func (fake *FakeActor) GetOrganizationLabelsArgsForCall(i int) string {
	fake.getOrganizationLabelsMutex.RLock()
	defer fake.getOrganizationLabelsMutex.RUnlock()
	argsForCall := fake.getOrganizationLabelsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetOrganizationLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationLabelsMutex.Lock()
	defer fake.getOrganizationLabelsMutex.Unlock()
	fake.GetOrganizationLabelsStub = nil
	fake.getOrganizationLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationLabelsMutex.Lock()
	defer fake.getOrganizationLabelsMutex.Unlock()
	fake.GetOrganizationLabelsStub = nil
	if fake.getOrganizationLabelsReturnsOnCall == nil {
		fake.getOrganizationLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationQuotaByName(arg1 string) (resources.OrganizationQuota, v7action.Warnings, error) {
	fake.getOrganizationQuotaByNameMutex.Lock()
	ret, specificReturn := fake.getOrganizationQuotaByNameReturnsOnCall[len(fake.getOrganizationQuotaByNameArgsForCall)]
	fake.getOrganizationQuotaByNameArgsForCall = append(fake.getOrganizationQuotaByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationQuotaByName", []interface{}{arg1})
	fake.getOrganizationQuotaByNameMutex.Unlock()
	if fake.GetOrganizationQuotaByNameStub != nil {
		return fake.GetOrganizationQuotaByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationQuotaByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrganizationQuotaByNameCallCount() int {
	fake.getOrganizationQuotaByNameMutex.RLock()
	defer fake.getOrganizationQuotaByNameMutex.RUnlock()
	return len(fake.getOrganizationQuotaByNameArgsForCall)
}

func (fake *FakeActor) GetOrganizationQuotaByNameCalls(stub func(string) (resources.OrganizationQuota, v7action.Warnings, error)) {
	fake.getOrganizationQuotaByNameMutex.Lock()
	defer fake.getOrganizationQuotaByNameMutex.Unlock()
	fake.GetOrganizationQuotaByNameStub = stub
}

func (fake *FakeActor) GetOrganizationQuotaByNameArgsForCall(i int) string {
	fake.getOrganizationQuotaByNameMutex.RLock()
	defer fake.getOrganizationQuotaByNameMutex.RUnlock()
	argsForCall := fake.getOrganizationQuotaByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetOrganizationQuotaByNameReturns(result1 resources.OrganizationQuota, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationQuotaByNameMutex.Lock()
	defer fake.getOrganizationQuotaByNameMutex.Unlock()
	fake.GetOrganizationQuotaByNameStub = nil
	fake.getOrganizationQuotaByNameReturns = struct {
		result1 resources.OrganizationQuota
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationQuotaByNameReturnsOnCall(i int, result1 resources.OrganizationQuota, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationQuotaByNameMutex.Lock()
	defer fake.getOrganizationQuotaByNameMutex.Unlock()
	fake.GetOrganizationQuotaByNameStub = nil
	if fake.getOrganizationQuotaByNameReturnsOnCall == nil {
		fake.getOrganizationQuotaByNameReturnsOnCall = make(map[int]struct {
			result1 resources.OrganizationQuota
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationQuotaByNameReturnsOnCall[i] = struct {
		result1 resources.OrganizationQuota
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeActor) GetOrganizationQuotasCalls(stub func() ([]resources.OrganizationQuota, v7action.Warnings, error)) {
	fake.getOrganizationQuotasMutex.Lock()
	defer fake.getOrganizationQuotasMutex.Unlock()
	fake.GetOrganizationQuotasStub = stub
}

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

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

func (fake *FakeActor) GetOrganizationSpaces(arg1 string) ([]resources.Space, v7action.Warnings, error) {
	fake.getOrganizationSpacesMutex.Lock()
	ret, specificReturn := fake.getOrganizationSpacesReturnsOnCall[len(fake.getOrganizationSpacesArgsForCall)]
	fake.getOrganizationSpacesArgsForCall = append(fake.getOrganizationSpacesArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationSpaces", []interface{}{arg1})
	fake.getOrganizationSpacesMutex.Unlock()
	if fake.GetOrganizationSpacesStub != nil {
		return fake.GetOrganizationSpacesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationSpacesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrganizationSpacesCallCount() int {
	fake.getOrganizationSpacesMutex.RLock()
	defer fake.getOrganizationSpacesMutex.RUnlock()
	return len(fake.getOrganizationSpacesArgsForCall)
}

func (fake *FakeActor) GetOrganizationSpacesCalls(stub func(string) ([]resources.Space, v7action.Warnings, error)) {
	fake.getOrganizationSpacesMutex.Lock()
	defer fake.getOrganizationSpacesMutex.Unlock()
	fake.GetOrganizationSpacesStub = stub
}

func (fake *FakeActor) GetOrganizationSpacesArgsForCall(i int) string {
	fake.getOrganizationSpacesMutex.RLock()
	defer fake.getOrganizationSpacesMutex.RUnlock()
	argsForCall := fake.getOrganizationSpacesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetOrganizationSpacesReturns(result1 []resources.Space, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationSpacesMutex.Lock()
	defer fake.getOrganizationSpacesMutex.Unlock()
	fake.GetOrganizationSpacesStub = nil
	fake.getOrganizationSpacesReturns = struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationSpacesReturnsOnCall(i int, result1 []resources.Space, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationSpacesMutex.Lock()
	defer fake.getOrganizationSpacesMutex.Unlock()
	fake.GetOrganizationSpacesStub = nil
	if fake.getOrganizationSpacesReturnsOnCall == nil {
		fake.getOrganizationSpacesReturnsOnCall = make(map[int]struct {
			result1 []resources.Space
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationSpacesReturnsOnCall[i] = struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationSpacesWithLabelSelector(arg1 string, arg2 string) ([]resources.Space, v7action.Warnings, error) {
	fake.getOrganizationSpacesWithLabelSelectorMutex.Lock()
	ret, specificReturn := fake.getOrganizationSpacesWithLabelSelectorReturnsOnCall[len(fake.getOrganizationSpacesWithLabelSelectorArgsForCall)]
	fake.getOrganizationSpacesWithLabelSelectorArgsForCall = append(fake.getOrganizationSpacesWithLabelSelectorArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetOrganizationSpacesWithLabelSelector", []interface{}{arg1, arg2})
	fake.getOrganizationSpacesWithLabelSelectorMutex.Unlock()
	if fake.GetOrganizationSpacesWithLabelSelectorStub != nil {
		return fake.GetOrganizationSpacesWithLabelSelectorStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationSpacesWithLabelSelectorReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorCallCount() int {
	fake.getOrganizationSpacesWithLabelSelectorMutex.RLock()
	defer fake.getOrganizationSpacesWithLabelSelectorMutex.RUnlock()
	return len(fake.getOrganizationSpacesWithLabelSelectorArgsForCall)
}

func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorCalls(stub func(string, string) ([]resources.Space, v7action.Warnings, error)) {
	fake.getOrganizationSpacesWithLabelSelectorMutex.Lock()
	defer fake.getOrganizationSpacesWithLabelSelectorMutex.Unlock()
	fake.GetOrganizationSpacesWithLabelSelectorStub = stub
}

func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorArgsForCall(i int) (string, string) {
	fake.getOrganizationSpacesWithLabelSelectorMutex.RLock()
	defer fake.getOrganizationSpacesWithLabelSelectorMutex.RUnlock()
	argsForCall := fake.getOrganizationSpacesWithLabelSelectorArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorReturns(result1 []resources.Space, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationSpacesWithLabelSelectorMutex.Lock()
	defer fake.getOrganizationSpacesWithLabelSelectorMutex.Unlock()
	fake.GetOrganizationSpacesWithLabelSelectorStub = nil
	fake.getOrganizationSpacesWithLabelSelectorReturns = struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationSpacesWithLabelSelectorReturnsOnCall(i int, result1 []resources.Space, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationSpacesWithLabelSelectorMutex.Lock()
	defer fake.getOrganizationSpacesWithLabelSelectorMutex.Unlock()
	fake.GetOrganizationSpacesWithLabelSelectorStub = nil
	if fake.getOrganizationSpacesWithLabelSelectorReturnsOnCall == nil {
		fake.getOrganizationSpacesWithLabelSelectorReturnsOnCall = make(map[int]struct {
			result1 []resources.Space
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationSpacesWithLabelSelectorReturnsOnCall[i] = struct {
		result1 []resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationSummaryByName(arg1 string) (v7action.OrganizationSummary, v7action.Warnings, error) {
	fake.getOrganizationSummaryByNameMutex.Lock()
	ret, specificReturn := fake.getOrganizationSummaryByNameReturnsOnCall[len(fake.getOrganizationSummaryByNameArgsForCall)]
	fake.getOrganizationSummaryByNameArgsForCall = append(fake.getOrganizationSummaryByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetOrganizationSummaryByName", []interface{}{arg1})
	fake.getOrganizationSummaryByNameMutex.Unlock()
	if fake.GetOrganizationSummaryByNameStub != nil {
		return fake.GetOrganizationSummaryByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getOrganizationSummaryByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetOrganizationSummaryByNameCallCount() int {
	fake.getOrganizationSummaryByNameMutex.RLock()
	defer fake.getOrganizationSummaryByNameMutex.RUnlock()
	return len(fake.getOrganizationSummaryByNameArgsForCall)
}

func (fake *FakeActor) GetOrganizationSummaryByNameCalls(stub func(string) (v7action.OrganizationSummary, v7action.Warnings, error)) {
	fake.getOrganizationSummaryByNameMutex.Lock()
	defer fake.getOrganizationSummaryByNameMutex.Unlock()
	fake.GetOrganizationSummaryByNameStub = stub
}

func (fake *FakeActor) GetOrganizationSummaryByNameArgsForCall(i int) string {
	fake.getOrganizationSummaryByNameMutex.RLock()
	defer fake.getOrganizationSummaryByNameMutex.RUnlock()
	argsForCall := fake.getOrganizationSummaryByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetOrganizationSummaryByNameReturns(result1 v7action.OrganizationSummary, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationSummaryByNameMutex.Lock()
	defer fake.getOrganizationSummaryByNameMutex.Unlock()
	fake.GetOrganizationSummaryByNameStub = nil
	fake.getOrganizationSummaryByNameReturns = struct {
		result1 v7action.OrganizationSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizationSummaryByNameReturnsOnCall(i int, result1 v7action.OrganizationSummary, result2 v7action.Warnings, result3 error) {
	fake.getOrganizationSummaryByNameMutex.Lock()
	defer fake.getOrganizationSummaryByNameMutex.Unlock()
	fake.GetOrganizationSummaryByNameStub = nil
	if fake.getOrganizationSummaryByNameReturnsOnCall == nil {
		fake.getOrganizationSummaryByNameReturnsOnCall = make(map[int]struct {
			result1 v7action.OrganizationSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationSummaryByNameReturnsOnCall[i] = struct {
		result1 v7action.OrganizationSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetOrganizations(arg1 string) ([]resources.Organization, v7action.Warnings, error) {
	fake.getOrganizationsMutex.Lock()
	ret, specificReturn := fake.getOrganizationsReturnsOnCall[len(fake.getOrganizationsArgsForCall)]
	fake.getOrganizationsArgsForCall = append(fake.getOrganizationsArgsForCall, struct {
		arg1 string
	}{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 *FakeActor) GetOrganizationsCallCount() int {
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	return len(fake.getOrganizationsArgsForCall)
}

func (fake *FakeActor) GetOrganizationsCalls(stub func(string) ([]resources.Organization, v7action.Warnings, error)) {
	fake.getOrganizationsMutex.Lock()
	defer fake.getOrganizationsMutex.Unlock()
	fake.GetOrganizationsStub = stub
}

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

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

func (fake *FakeActor) GetOrganizationsReturnsOnCall(i int, result1 []resources.Organization, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.getOrganizationsReturnsOnCall[i] = struct {
		result1 []resources.Organization
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetProcessByTypeAndApplication(arg1 string, arg2 string) (resources.Process, v7action.Warnings, error) {
	fake.getProcessByTypeAndApplicationMutex.Lock()
	ret, specificReturn := fake.getProcessByTypeAndApplicationReturnsOnCall[len(fake.getProcessByTypeAndApplicationArgsForCall)]
	fake.getProcessByTypeAndApplicationArgsForCall = append(fake.getProcessByTypeAndApplicationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetProcessByTypeAndApplication", []interface{}{arg1, arg2})
	fake.getProcessByTypeAndApplicationMutex.Unlock()
	if fake.GetProcessByTypeAndApplicationStub != nil {
		return fake.GetProcessByTypeAndApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getProcessByTypeAndApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetProcessByTypeAndApplicationCallCount() int {
	fake.getProcessByTypeAndApplicationMutex.RLock()
	defer fake.getProcessByTypeAndApplicationMutex.RUnlock()
	return len(fake.getProcessByTypeAndApplicationArgsForCall)
}

func (fake *FakeActor) GetProcessByTypeAndApplicationCalls(stub func(string, string) (resources.Process, v7action.Warnings, error)) {
	fake.getProcessByTypeAndApplicationMutex.Lock()
	defer fake.getProcessByTypeAndApplicationMutex.Unlock()
	fake.GetProcessByTypeAndApplicationStub = stub
}

func (fake *FakeActor) GetProcessByTypeAndApplicationArgsForCall(i int) (string, string) {
	fake.getProcessByTypeAndApplicationMutex.RLock()
	defer fake.getProcessByTypeAndApplicationMutex.RUnlock()
	argsForCall := fake.getProcessByTypeAndApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetProcessByTypeAndApplicationReturns(result1 resources.Process, result2 v7action.Warnings, result3 error) {
	fake.getProcessByTypeAndApplicationMutex.Lock()
	defer fake.getProcessByTypeAndApplicationMutex.Unlock()
	fake.GetProcessByTypeAndApplicationStub = nil
	fake.getProcessByTypeAndApplicationReturns = struct {
		result1 resources.Process
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetProcessByTypeAndApplicationReturnsOnCall(i int, result1 resources.Process, result2 v7action.Warnings, result3 error) {
	fake.getProcessByTypeAndApplicationMutex.Lock()
	defer fake.getProcessByTypeAndApplicationMutex.Unlock()
	fake.GetProcessByTypeAndApplicationStub = nil
	if fake.getProcessByTypeAndApplicationReturnsOnCall == nil {
		fake.getProcessByTypeAndApplicationReturnsOnCall = make(map[int]struct {
			result1 resources.Process
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getProcessByTypeAndApplicationReturnsOnCall[i] = struct {
		result1 resources.Process
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRawApplicationManifestByNameAndSpace(arg1 string, arg2 string) ([]byte, v7action.Warnings, error) {
	fake.getRawApplicationManifestByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getRawApplicationManifestByNameAndSpaceReturnsOnCall[len(fake.getRawApplicationManifestByNameAndSpaceArgsForCall)]
	fake.getRawApplicationManifestByNameAndSpaceArgsForCall = append(fake.getRawApplicationManifestByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRawApplicationManifestByNameAndSpace", []interface{}{arg1, arg2})
	fake.getRawApplicationManifestByNameAndSpaceMutex.Unlock()
	if fake.GetRawApplicationManifestByNameAndSpaceStub != nil {
		return fake.GetRawApplicationManifestByNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRawApplicationManifestByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceCallCount() int {
	fake.getRawApplicationManifestByNameAndSpaceMutex.RLock()
	defer fake.getRawApplicationManifestByNameAndSpaceMutex.RUnlock()
	return len(fake.getRawApplicationManifestByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceCalls(stub func(string, string) ([]byte, v7action.Warnings, error)) {
	fake.getRawApplicationManifestByNameAndSpaceMutex.Lock()
	defer fake.getRawApplicationManifestByNameAndSpaceMutex.Unlock()
	fake.GetRawApplicationManifestByNameAndSpaceStub = stub
}

func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getRawApplicationManifestByNameAndSpaceMutex.RLock()
	defer fake.getRawApplicationManifestByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getRawApplicationManifestByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceReturns(result1 []byte, result2 v7action.Warnings, result3 error) {
	fake.getRawApplicationManifestByNameAndSpaceMutex.Lock()
	defer fake.getRawApplicationManifestByNameAndSpaceMutex.Unlock()
	fake.GetRawApplicationManifestByNameAndSpaceStub = nil
	fake.getRawApplicationManifestByNameAndSpaceReturns = struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRawApplicationManifestByNameAndSpaceReturnsOnCall(i int, result1 []byte, result2 v7action.Warnings, result3 error) {
	fake.getRawApplicationManifestByNameAndSpaceMutex.Lock()
	defer fake.getRawApplicationManifestByNameAndSpaceMutex.Unlock()
	fake.GetRawApplicationManifestByNameAndSpaceStub = nil
	if fake.getRawApplicationManifestByNameAndSpaceReturnsOnCall == nil {
		fake.getRawApplicationManifestByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRawApplicationManifestByNameAndSpaceReturnsOnCall[i] = struct {
		result1 []byte
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpace(arg1 string, arg2 string) ([]v7action.Event, v7action.Warnings, error) {
	fake.getRecentEventsByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getRecentEventsByApplicationNameAndSpaceReturnsOnCall[len(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall)]
	fake.getRecentEventsByApplicationNameAndSpaceArgsForCall = append(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRecentEventsByApplicationNameAndSpace", []interface{}{arg1, arg2})
	fake.getRecentEventsByApplicationNameAndSpaceMutex.Unlock()
	if fake.GetRecentEventsByApplicationNameAndSpaceStub != nil {
		return fake.GetRecentEventsByApplicationNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRecentEventsByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceCallCount() int {
	fake.getRecentEventsByApplicationNameAndSpaceMutex.RLock()
	defer fake.getRecentEventsByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.getRecentEventsByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceCalls(stub func(string, string) ([]v7action.Event, v7action.Warnings, error)) {
	fake.getRecentEventsByApplicationNameAndSpaceMutex.Lock()
	defer fake.getRecentEventsByApplicationNameAndSpaceMutex.Unlock()
	fake.GetRecentEventsByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getRecentEventsByApplicationNameAndSpaceMutex.RLock()
	defer fake.getRecentEventsByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getRecentEventsByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceReturns(result1 []v7action.Event, result2 v7action.Warnings, result3 error) {
	fake.getRecentEventsByApplicationNameAndSpaceMutex.Lock()
	defer fake.getRecentEventsByApplicationNameAndSpaceMutex.Unlock()
	fake.GetRecentEventsByApplicationNameAndSpaceStub = nil
	fake.getRecentEventsByApplicationNameAndSpaceReturns = struct {
		result1 []v7action.Event
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRecentEventsByApplicationNameAndSpaceReturnsOnCall(i int, result1 []v7action.Event, result2 v7action.Warnings, result3 error) {
	fake.getRecentEventsByApplicationNameAndSpaceMutex.Lock()
	defer fake.getRecentEventsByApplicationNameAndSpaceMutex.Unlock()
	fake.GetRecentEventsByApplicationNameAndSpaceStub = nil
	if fake.getRecentEventsByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.getRecentEventsByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []v7action.Event
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRecentEventsByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 []v7action.Event
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpace(arg1 string, arg2 string, arg3 sharedaction.LogCacheClient) ([]sharedaction.LogMessage, v7action.Warnings, error) {
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getRecentLogsForApplicationByNameAndSpaceReturnsOnCall[len(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall)]
	fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall = append(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 sharedaction.LogCacheClient
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetRecentLogsForApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.Unlock()
	if fake.GetRecentLogsForApplicationByNameAndSpaceStub != nil {
		return fake.GetRecentLogsForApplicationByNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRecentLogsForApplicationByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceCallCount() int {
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.RLock()
	defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.RUnlock()
	return len(fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceCalls(stub func(string, string, sharedaction.LogCacheClient) ([]sharedaction.LogMessage, v7action.Warnings, error)) {
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.Lock()
	defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.Unlock()
	fake.GetRecentLogsForApplicationByNameAndSpaceStub = stub
}

func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceArgsForCall(i int) (string, string, sharedaction.LogCacheClient) {
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.RLock()
	defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getRecentLogsForApplicationByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceReturns(result1 []sharedaction.LogMessage, result2 v7action.Warnings, result3 error) {
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.Lock()
	defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.Unlock()
	fake.GetRecentLogsForApplicationByNameAndSpaceStub = nil
	fake.getRecentLogsForApplicationByNameAndSpaceReturns = struct {
		result1 []sharedaction.LogMessage
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRecentLogsForApplicationByNameAndSpaceReturnsOnCall(i int, result1 []sharedaction.LogMessage, result2 v7action.Warnings, result3 error) {
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.Lock()
	defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.Unlock()
	fake.GetRecentLogsForApplicationByNameAndSpaceStub = nil
	if fake.getRecentLogsForApplicationByNameAndSpaceReturnsOnCall == nil {
		fake.getRecentLogsForApplicationByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []sharedaction.LogMessage
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRecentLogsForApplicationByNameAndSpaceReturnsOnCall[i] = struct {
		result1 []sharedaction.LogMessage
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRevisionByApplicationAndVersion(arg1 string, arg2 int) (resources.Revision, v7action.Warnings, error) {
	fake.getRevisionByApplicationAndVersionMutex.Lock()
	ret, specificReturn := fake.getRevisionByApplicationAndVersionReturnsOnCall[len(fake.getRevisionByApplicationAndVersionArgsForCall)]
	fake.getRevisionByApplicationAndVersionArgsForCall = append(fake.getRevisionByApplicationAndVersionArgsForCall, struct {
		arg1 string
		arg2 int
	}{arg1, arg2})
	fake.recordInvocation("GetRevisionByApplicationAndVersion", []interface{}{arg1, arg2})
	fake.getRevisionByApplicationAndVersionMutex.Unlock()
	if fake.GetRevisionByApplicationAndVersionStub != nil {
		return fake.GetRevisionByApplicationAndVersionStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRevisionByApplicationAndVersionReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRevisionByApplicationAndVersionCallCount() int {
	fake.getRevisionByApplicationAndVersionMutex.RLock()
	defer fake.getRevisionByApplicationAndVersionMutex.RUnlock()
	return len(fake.getRevisionByApplicationAndVersionArgsForCall)
}

func (fake *FakeActor) GetRevisionByApplicationAndVersionCalls(stub func(string, int) (resources.Revision, v7action.Warnings, error)) {
	fake.getRevisionByApplicationAndVersionMutex.Lock()
	defer fake.getRevisionByApplicationAndVersionMutex.Unlock()
	fake.GetRevisionByApplicationAndVersionStub = stub
}

func (fake *FakeActor) GetRevisionByApplicationAndVersionArgsForCall(i int) (string, int) {
	fake.getRevisionByApplicationAndVersionMutex.RLock()
	defer fake.getRevisionByApplicationAndVersionMutex.RUnlock()
	argsForCall := fake.getRevisionByApplicationAndVersionArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRevisionByApplicationAndVersionReturns(result1 resources.Revision, result2 v7action.Warnings, result3 error) {
	fake.getRevisionByApplicationAndVersionMutex.Lock()
	defer fake.getRevisionByApplicationAndVersionMutex.Unlock()
	fake.GetRevisionByApplicationAndVersionStub = nil
	fake.getRevisionByApplicationAndVersionReturns = struct {
		result1 resources.Revision
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRevisionByApplicationAndVersionReturnsOnCall(i int, result1 resources.Revision, result2 v7action.Warnings, result3 error) {
	fake.getRevisionByApplicationAndVersionMutex.Lock()
	defer fake.getRevisionByApplicationAndVersionMutex.Unlock()
	fake.GetRevisionByApplicationAndVersionStub = nil
	if fake.getRevisionByApplicationAndVersionReturnsOnCall == nil {
		fake.getRevisionByApplicationAndVersionReturnsOnCall = make(map[int]struct {
			result1 resources.Revision
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRevisionByApplicationAndVersionReturnsOnCall[i] = struct {
		result1 resources.Revision
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRevisionsByApplicationNameAndSpace(arg1 string, arg2 string) ([]resources.Revision, v7action.Warnings, error) {
	fake.getRevisionsByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getRevisionsByApplicationNameAndSpaceReturnsOnCall[len(fake.getRevisionsByApplicationNameAndSpaceArgsForCall)]
	fake.getRevisionsByApplicationNameAndSpaceArgsForCall = append(fake.getRevisionsByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRevisionsByApplicationNameAndSpace", []interface{}{arg1, arg2})
	fake.getRevisionsByApplicationNameAndSpaceMutex.Unlock()
	if fake.GetRevisionsByApplicationNameAndSpaceStub != nil {
		return fake.GetRevisionsByApplicationNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRevisionsByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceCallCount() int {
	fake.getRevisionsByApplicationNameAndSpaceMutex.RLock()
	defer fake.getRevisionsByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.getRevisionsByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceCalls(stub func(string, string) ([]resources.Revision, v7action.Warnings, error)) {
	fake.getRevisionsByApplicationNameAndSpaceMutex.Lock()
	defer fake.getRevisionsByApplicationNameAndSpaceMutex.Unlock()
	fake.GetRevisionsByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getRevisionsByApplicationNameAndSpaceMutex.RLock()
	defer fake.getRevisionsByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getRevisionsByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceReturns(result1 []resources.Revision, result2 v7action.Warnings, result3 error) {
	fake.getRevisionsByApplicationNameAndSpaceMutex.Lock()
	defer fake.getRevisionsByApplicationNameAndSpaceMutex.Unlock()
	fake.GetRevisionsByApplicationNameAndSpaceStub = nil
	fake.getRevisionsByApplicationNameAndSpaceReturns = struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRevisionsByApplicationNameAndSpaceReturnsOnCall(i int, result1 []resources.Revision, result2 v7action.Warnings, result3 error) {
	fake.getRevisionsByApplicationNameAndSpaceMutex.Lock()
	defer fake.getRevisionsByApplicationNameAndSpaceMutex.Unlock()
	fake.GetRevisionsByApplicationNameAndSpaceStub = nil
	if fake.getRevisionsByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.getRevisionsByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []resources.Revision
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRevisionsByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 []resources.Revision
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRootResponse() (v7action.Info, v7action.Warnings, error) {
	fake.getRootResponseMutex.Lock()
	ret, specificReturn := fake.getRootResponseReturnsOnCall[len(fake.getRootResponseArgsForCall)]
	fake.getRootResponseArgsForCall = append(fake.getRootResponseArgsForCall, struct {
	}{})
	fake.recordInvocation("GetRootResponse", []interface{}{})
	fake.getRootResponseMutex.Unlock()
	if fake.GetRootResponseStub != nil {
		return fake.GetRootResponseStub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRootResponseReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRootResponseCallCount() int {
	fake.getRootResponseMutex.RLock()
	defer fake.getRootResponseMutex.RUnlock()
	return len(fake.getRootResponseArgsForCall)
}

func (fake *FakeActor) GetRootResponseCalls(stub func() (v7action.Info, v7action.Warnings, error)) {
	fake.getRootResponseMutex.Lock()
	defer fake.getRootResponseMutex.Unlock()
	fake.GetRootResponseStub = stub
}

func (fake *FakeActor) GetRootResponseReturns(result1 v7action.Info, result2 v7action.Warnings, result3 error) {
	fake.getRootResponseMutex.Lock()
	defer fake.getRootResponseMutex.Unlock()
	fake.GetRootResponseStub = nil
	fake.getRootResponseReturns = struct {
		result1 v7action.Info
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRootResponseReturnsOnCall(i int, result1 v7action.Info, result2 v7action.Warnings, result3 error) {
	fake.getRootResponseMutex.Lock()
	defer fake.getRootResponseMutex.Unlock()
	fake.GetRootResponseStub = nil
	if fake.getRootResponseReturnsOnCall == nil {
		fake.getRootResponseReturnsOnCall = make(map[int]struct {
			result1 v7action.Info
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRootResponseReturnsOnCall[i] = struct {
		result1 v7action.Info
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouteByAttributes(arg1 resources.Domain, arg2 string, arg3 string, arg4 int) (resources.Route, v7action.Warnings, error) {
	fake.getRouteByAttributesMutex.Lock()
	ret, specificReturn := fake.getRouteByAttributesReturnsOnCall[len(fake.getRouteByAttributesArgsForCall)]
	fake.getRouteByAttributesArgsForCall = append(fake.getRouteByAttributesArgsForCall, struct {
		arg1 resources.Domain
		arg2 string
		arg3 string
		arg4 int
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("GetRouteByAttributes", []interface{}{arg1, arg2, arg3, arg4})
	fake.getRouteByAttributesMutex.Unlock()
	if fake.GetRouteByAttributesStub != nil {
		return fake.GetRouteByAttributesStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRouteByAttributesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRouteByAttributesCallCount() int {
	fake.getRouteByAttributesMutex.RLock()
	defer fake.getRouteByAttributesMutex.RUnlock()
	return len(fake.getRouteByAttributesArgsForCall)
}

func (fake *FakeActor) GetRouteByAttributesCalls(stub func(resources.Domain, string, string, int) (resources.Route, v7action.Warnings, error)) {
	fake.getRouteByAttributesMutex.Lock()
	defer fake.getRouteByAttributesMutex.Unlock()
	fake.GetRouteByAttributesStub = stub
}

func (fake *FakeActor) GetRouteByAttributesArgsForCall(i int) (resources.Domain, string, string, int) {
	fake.getRouteByAttributesMutex.RLock()
	defer fake.getRouteByAttributesMutex.RUnlock()
	argsForCall := fake.getRouteByAttributesArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) GetRouteByAttributesReturns(result1 resources.Route, result2 v7action.Warnings, result3 error) {
	fake.getRouteByAttributesMutex.Lock()
	defer fake.getRouteByAttributesMutex.Unlock()
	fake.GetRouteByAttributesStub = nil
	fake.getRouteByAttributesReturns = struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouteByAttributesReturnsOnCall(i int, result1 resources.Route, result2 v7action.Warnings, result3 error) {
	fake.getRouteByAttributesMutex.Lock()
	defer fake.getRouteByAttributesMutex.Unlock()
	fake.GetRouteByAttributesStub = nil
	if fake.getRouteByAttributesReturnsOnCall == nil {
		fake.getRouteByAttributesReturnsOnCall = make(map[int]struct {
			result1 resources.Route
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRouteByAttributesReturnsOnCall[i] = struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouteDestinationByAppGUID(arg1 resources.Route, arg2 string) (resources.RouteDestination, error) {
	fake.getRouteDestinationByAppGUIDMutex.Lock()
	ret, specificReturn := fake.getRouteDestinationByAppGUIDReturnsOnCall[len(fake.getRouteDestinationByAppGUIDArgsForCall)]
	fake.getRouteDestinationByAppGUIDArgsForCall = append(fake.getRouteDestinationByAppGUIDArgsForCall, struct {
		arg1 resources.Route
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRouteDestinationByAppGUID", []interface{}{arg1, arg2})
	fake.getRouteDestinationByAppGUIDMutex.Unlock()
	if fake.GetRouteDestinationByAppGUIDStub != nil {
		return fake.GetRouteDestinationByAppGUIDStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getRouteDestinationByAppGUIDReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetRouteDestinationByAppGUIDCallCount() int {
	fake.getRouteDestinationByAppGUIDMutex.RLock()
	defer fake.getRouteDestinationByAppGUIDMutex.RUnlock()
	return len(fake.getRouteDestinationByAppGUIDArgsForCall)
}

func (fake *FakeActor) GetRouteDestinationByAppGUIDCalls(stub func(resources.Route, string) (resources.RouteDestination, error)) {
	fake.getRouteDestinationByAppGUIDMutex.Lock()
	defer fake.getRouteDestinationByAppGUIDMutex.Unlock()
	fake.GetRouteDestinationByAppGUIDStub = stub
}

func (fake *FakeActor) GetRouteDestinationByAppGUIDArgsForCall(i int) (resources.Route, string) {
	fake.getRouteDestinationByAppGUIDMutex.RLock()
	defer fake.getRouteDestinationByAppGUIDMutex.RUnlock()
	argsForCall := fake.getRouteDestinationByAppGUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRouteDestinationByAppGUIDReturns(result1 resources.RouteDestination, result2 error) {
	fake.getRouteDestinationByAppGUIDMutex.Lock()
	defer fake.getRouteDestinationByAppGUIDMutex.Unlock()
	fake.GetRouteDestinationByAppGUIDStub = nil
	fake.getRouteDestinationByAppGUIDReturns = struct {
		result1 resources.RouteDestination
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetRouteDestinationByAppGUIDReturnsOnCall(i int, result1 resources.RouteDestination, result2 error) {
	fake.getRouteDestinationByAppGUIDMutex.Lock()
	defer fake.getRouteDestinationByAppGUIDMutex.Unlock()
	fake.GetRouteDestinationByAppGUIDStub = nil
	if fake.getRouteDestinationByAppGUIDReturnsOnCall == nil {
		fake.getRouteDestinationByAppGUIDReturnsOnCall = make(map[int]struct {
			result1 resources.RouteDestination
			result2 error
		})
	}
	fake.getRouteDestinationByAppGUIDReturnsOnCall[i] = struct {
		result1 resources.RouteDestination
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetRouteLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getRouteLabelsMutex.Lock()
	ret, specificReturn := fake.getRouteLabelsReturnsOnCall[len(fake.getRouteLabelsArgsForCall)]
	fake.getRouteLabelsArgsForCall = append(fake.getRouteLabelsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRouteLabels", []interface{}{arg1, arg2})
	fake.getRouteLabelsMutex.Unlock()
	if fake.GetRouteLabelsStub != nil {
		return fake.GetRouteLabelsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRouteLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRouteLabelsCallCount() int {
	fake.getRouteLabelsMutex.RLock()
	defer fake.getRouteLabelsMutex.RUnlock()
	return len(fake.getRouteLabelsArgsForCall)
}

func (fake *FakeActor) GetRouteLabelsCalls(stub func(string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getRouteLabelsMutex.Lock()
	defer fake.getRouteLabelsMutex.Unlock()
	fake.GetRouteLabelsStub = stub
}

func (fake *FakeActor) GetRouteLabelsArgsForCall(i int) (string, string) {
	fake.getRouteLabelsMutex.RLock()
	defer fake.getRouteLabelsMutex.RUnlock()
	argsForCall := fake.getRouteLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRouteLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getRouteLabelsMutex.Lock()
	defer fake.getRouteLabelsMutex.Unlock()
	fake.GetRouteLabelsStub = nil
	fake.getRouteLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouteLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getRouteLabelsMutex.Lock()
	defer fake.getRouteLabelsMutex.Unlock()
	fake.GetRouteLabelsStub = nil
	if fake.getRouteLabelsReturnsOnCall == nil {
		fake.getRouteLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRouteLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouteSummaries(arg1 []resources.Route) ([]v7action.RouteSummary, v7action.Warnings, error) {
	var arg1Copy []resources.Route
	if arg1 != nil {
		arg1Copy = make([]resources.Route, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.getRouteSummariesMutex.Lock()
	ret, specificReturn := fake.getRouteSummariesReturnsOnCall[len(fake.getRouteSummariesArgsForCall)]
	fake.getRouteSummariesArgsForCall = append(fake.getRouteSummariesArgsForCall, struct {
		arg1 []resources.Route
	}{arg1Copy})
	fake.recordInvocation("GetRouteSummaries", []interface{}{arg1Copy})
	fake.getRouteSummariesMutex.Unlock()
	if fake.GetRouteSummariesStub != nil {
		return fake.GetRouteSummariesStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRouteSummariesReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRouteSummariesCallCount() int {
	fake.getRouteSummariesMutex.RLock()
	defer fake.getRouteSummariesMutex.RUnlock()
	return len(fake.getRouteSummariesArgsForCall)
}

func (fake *FakeActor) GetRouteSummariesCalls(stub func([]resources.Route) ([]v7action.RouteSummary, v7action.Warnings, error)) {
	fake.getRouteSummariesMutex.Lock()
	defer fake.getRouteSummariesMutex.Unlock()
	fake.GetRouteSummariesStub = stub
}

func (fake *FakeActor) GetRouteSummariesArgsForCall(i int) []resources.Route {
	fake.getRouteSummariesMutex.RLock()
	defer fake.getRouteSummariesMutex.RUnlock()
	argsForCall := fake.getRouteSummariesArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetRouteSummariesReturns(result1 []v7action.RouteSummary, result2 v7action.Warnings, result3 error) {
	fake.getRouteSummariesMutex.Lock()
	defer fake.getRouteSummariesMutex.Unlock()
	fake.GetRouteSummariesStub = nil
	fake.getRouteSummariesReturns = struct {
		result1 []v7action.RouteSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouteSummariesReturnsOnCall(i int, result1 []v7action.RouteSummary, result2 v7action.Warnings, result3 error) {
	fake.getRouteSummariesMutex.Lock()
	defer fake.getRouteSummariesMutex.Unlock()
	fake.GetRouteSummariesStub = nil
	if fake.getRouteSummariesReturnsOnCall == nil {
		fake.getRouteSummariesReturnsOnCall = make(map[int]struct {
			result1 []v7action.RouteSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRouteSummariesReturnsOnCall[i] = struct {
		result1 []v7action.RouteSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRouterGroups() ([]v7action.RouterGroup, error) {
	fake.getRouterGroupsMutex.Lock()
	ret, specificReturn := fake.getRouterGroupsReturnsOnCall[len(fake.getRouterGroupsArgsForCall)]
	fake.getRouterGroupsArgsForCall = append(fake.getRouterGroupsArgsForCall, struct {
	}{})
	fake.recordInvocation("GetRouterGroups", []interface{}{})
	fake.getRouterGroupsMutex.Unlock()
	if fake.GetRouterGroupsStub != nil {
		return fake.GetRouterGroupsStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getRouterGroupsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetRouterGroupsCallCount() int {
	fake.getRouterGroupsMutex.RLock()
	defer fake.getRouterGroupsMutex.RUnlock()
	return len(fake.getRouterGroupsArgsForCall)
}

func (fake *FakeActor) GetRouterGroupsCalls(stub func() ([]v7action.RouterGroup, error)) {
	fake.getRouterGroupsMutex.Lock()
	defer fake.getRouterGroupsMutex.Unlock()
	fake.GetRouterGroupsStub = stub
}

func (fake *FakeActor) GetRouterGroupsReturns(result1 []v7action.RouterGroup, result2 error) {
	fake.getRouterGroupsMutex.Lock()
	defer fake.getRouterGroupsMutex.Unlock()
	fake.GetRouterGroupsStub = nil
	fake.getRouterGroupsReturns = struct {
		result1 []v7action.RouterGroup
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetRouterGroupsReturnsOnCall(i int, result1 []v7action.RouterGroup, result2 error) {
	fake.getRouterGroupsMutex.Lock()
	defer fake.getRouterGroupsMutex.Unlock()
	fake.GetRouterGroupsStub = nil
	if fake.getRouterGroupsReturnsOnCall == nil {
		fake.getRouterGroupsReturnsOnCall = make(map[int]struct {
			result1 []v7action.RouterGroup
			result2 error
		})
	}
	fake.getRouterGroupsReturnsOnCall[i] = struct {
		result1 []v7action.RouterGroup
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetRoutesByOrg(arg1 string, arg2 string) ([]resources.Route, v7action.Warnings, error) {
	fake.getRoutesByOrgMutex.Lock()
	ret, specificReturn := fake.getRoutesByOrgReturnsOnCall[len(fake.getRoutesByOrgArgsForCall)]
	fake.getRoutesByOrgArgsForCall = append(fake.getRoutesByOrgArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRoutesByOrg", []interface{}{arg1, arg2})
	fake.getRoutesByOrgMutex.Unlock()
	if fake.GetRoutesByOrgStub != nil {
		return fake.GetRoutesByOrgStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRoutesByOrgReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRoutesByOrgCallCount() int {
	fake.getRoutesByOrgMutex.RLock()
	defer fake.getRoutesByOrgMutex.RUnlock()
	return len(fake.getRoutesByOrgArgsForCall)
}

func (fake *FakeActor) GetRoutesByOrgCalls(stub func(string, string) ([]resources.Route, v7action.Warnings, error)) {
	fake.getRoutesByOrgMutex.Lock()
	defer fake.getRoutesByOrgMutex.Unlock()
	fake.GetRoutesByOrgStub = stub
}

func (fake *FakeActor) GetRoutesByOrgArgsForCall(i int) (string, string) {
	fake.getRoutesByOrgMutex.RLock()
	defer fake.getRoutesByOrgMutex.RUnlock()
	argsForCall := fake.getRoutesByOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRoutesByOrgReturns(result1 []resources.Route, result2 v7action.Warnings, result3 error) {
	fake.getRoutesByOrgMutex.Lock()
	defer fake.getRoutesByOrgMutex.Unlock()
	fake.GetRoutesByOrgStub = nil
	fake.getRoutesByOrgReturns = struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRoutesByOrgReturnsOnCall(i int, result1 []resources.Route, result2 v7action.Warnings, result3 error) {
	fake.getRoutesByOrgMutex.Lock()
	defer fake.getRoutesByOrgMutex.Unlock()
	fake.GetRoutesByOrgStub = nil
	if fake.getRoutesByOrgReturnsOnCall == nil {
		fake.getRoutesByOrgReturnsOnCall = make(map[int]struct {
			result1 []resources.Route
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRoutesByOrgReturnsOnCall[i] = struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRoutesBySpace(arg1 string, arg2 string) ([]resources.Route, v7action.Warnings, error) {
	fake.getRoutesBySpaceMutex.Lock()
	ret, specificReturn := fake.getRoutesBySpaceReturnsOnCall[len(fake.getRoutesBySpaceArgsForCall)]
	fake.getRoutesBySpaceArgsForCall = append(fake.getRoutesBySpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetRoutesBySpace", []interface{}{arg1, arg2})
	fake.getRoutesBySpaceMutex.Unlock()
	if fake.GetRoutesBySpaceStub != nil {
		return fake.GetRoutesBySpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getRoutesBySpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetRoutesBySpaceCallCount() int {
	fake.getRoutesBySpaceMutex.RLock()
	defer fake.getRoutesBySpaceMutex.RUnlock()
	return len(fake.getRoutesBySpaceArgsForCall)
}

func (fake *FakeActor) GetRoutesBySpaceCalls(stub func(string, string) ([]resources.Route, v7action.Warnings, error)) {
	fake.getRoutesBySpaceMutex.Lock()
	defer fake.getRoutesBySpaceMutex.Unlock()
	fake.GetRoutesBySpaceStub = stub
}

func (fake *FakeActor) GetRoutesBySpaceArgsForCall(i int) (string, string) {
	fake.getRoutesBySpaceMutex.RLock()
	defer fake.getRoutesBySpaceMutex.RUnlock()
	argsForCall := fake.getRoutesBySpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetRoutesBySpaceReturns(result1 []resources.Route, result2 v7action.Warnings, result3 error) {
	fake.getRoutesBySpaceMutex.Lock()
	defer fake.getRoutesBySpaceMutex.Unlock()
	fake.GetRoutesBySpaceStub = nil
	fake.getRoutesBySpaceReturns = struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetRoutesBySpaceReturnsOnCall(i int, result1 []resources.Route, result2 v7action.Warnings, result3 error) {
	fake.getRoutesBySpaceMutex.Lock()
	defer fake.getRoutesBySpaceMutex.Unlock()
	fake.GetRoutesBySpaceStub = nil
	if fake.getRoutesBySpaceReturnsOnCall == nil {
		fake.getRoutesBySpaceReturnsOnCall = make(map[int]struct {
			result1 []resources.Route
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRoutesBySpaceReturnsOnCall[i] = struct {
		result1 []resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSSHEnabled(arg1 string) (ccv3.SSHEnabled, v7action.Warnings, error) {
	fake.getSSHEnabledMutex.Lock()
	ret, specificReturn := fake.getSSHEnabledReturnsOnCall[len(fake.getSSHEnabledArgsForCall)]
	fake.getSSHEnabledArgsForCall = append(fake.getSSHEnabledArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSSHEnabled", []interface{}{arg1})
	fake.getSSHEnabledMutex.Unlock()
	if fake.GetSSHEnabledStub != nil {
		return fake.GetSSHEnabledStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSSHEnabledReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSSHEnabledCallCount() int {
	fake.getSSHEnabledMutex.RLock()
	defer fake.getSSHEnabledMutex.RUnlock()
	return len(fake.getSSHEnabledArgsForCall)
}

func (fake *FakeActor) GetSSHEnabledCalls(stub func(string) (ccv3.SSHEnabled, v7action.Warnings, error)) {
	fake.getSSHEnabledMutex.Lock()
	defer fake.getSSHEnabledMutex.Unlock()
	fake.GetSSHEnabledStub = stub
}

func (fake *FakeActor) GetSSHEnabledArgsForCall(i int) string {
	fake.getSSHEnabledMutex.RLock()
	defer fake.getSSHEnabledMutex.RUnlock()
	argsForCall := fake.getSSHEnabledArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetSSHEnabledReturns(result1 ccv3.SSHEnabled, result2 v7action.Warnings, result3 error) {
	fake.getSSHEnabledMutex.Lock()
	defer fake.getSSHEnabledMutex.Unlock()
	fake.GetSSHEnabledStub = nil
	fake.getSSHEnabledReturns = struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSSHEnabledReturnsOnCall(i int, result1 ccv3.SSHEnabled, result2 v7action.Warnings, result3 error) {
	fake.getSSHEnabledMutex.Lock()
	defer fake.getSSHEnabledMutex.Unlock()
	fake.GetSSHEnabledStub = nil
	if fake.getSSHEnabledReturnsOnCall == nil {
		fake.getSSHEnabledReturnsOnCall = make(map[int]struct {
			result1 ccv3.SSHEnabled
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSSHEnabledReturnsOnCall[i] = struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSSHEnabledByAppName(arg1 string, arg2 string) (ccv3.SSHEnabled, v7action.Warnings, error) {
	fake.getSSHEnabledByAppNameMutex.Lock()
	ret, specificReturn := fake.getSSHEnabledByAppNameReturnsOnCall[len(fake.getSSHEnabledByAppNameArgsForCall)]
	fake.getSSHEnabledByAppNameArgsForCall = append(fake.getSSHEnabledByAppNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetSSHEnabledByAppName", []interface{}{arg1, arg2})
	fake.getSSHEnabledByAppNameMutex.Unlock()
	if fake.GetSSHEnabledByAppNameStub != nil {
		return fake.GetSSHEnabledByAppNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSSHEnabledByAppNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSSHEnabledByAppNameCallCount() int {
	fake.getSSHEnabledByAppNameMutex.RLock()
	defer fake.getSSHEnabledByAppNameMutex.RUnlock()
	return len(fake.getSSHEnabledByAppNameArgsForCall)
}

func (fake *FakeActor) GetSSHEnabledByAppNameCalls(stub func(string, string) (ccv3.SSHEnabled, v7action.Warnings, error)) {
	fake.getSSHEnabledByAppNameMutex.Lock()
	defer fake.getSSHEnabledByAppNameMutex.Unlock()
	fake.GetSSHEnabledByAppNameStub = stub
}

func (fake *FakeActor) GetSSHEnabledByAppNameArgsForCall(i int) (string, string) {
	fake.getSSHEnabledByAppNameMutex.RLock()
	defer fake.getSSHEnabledByAppNameMutex.RUnlock()
	argsForCall := fake.getSSHEnabledByAppNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetSSHEnabledByAppNameReturns(result1 ccv3.SSHEnabled, result2 v7action.Warnings, result3 error) {
	fake.getSSHEnabledByAppNameMutex.Lock()
	defer fake.getSSHEnabledByAppNameMutex.Unlock()
	fake.GetSSHEnabledByAppNameStub = nil
	fake.getSSHEnabledByAppNameReturns = struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSSHEnabledByAppNameReturnsOnCall(i int, result1 ccv3.SSHEnabled, result2 v7action.Warnings, result3 error) {
	fake.getSSHEnabledByAppNameMutex.Lock()
	defer fake.getSSHEnabledByAppNameMutex.Unlock()
	fake.GetSSHEnabledByAppNameStub = nil
	if fake.getSSHEnabledByAppNameReturnsOnCall == nil {
		fake.getSSHEnabledByAppNameReturnsOnCall = make(map[int]struct {
			result1 ccv3.SSHEnabled
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSSHEnabledByAppNameReturnsOnCall[i] = struct {
		result1 ccv3.SSHEnabled
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSSHPasscode() (string, error) {
	fake.getSSHPasscodeMutex.Lock()
	ret, specificReturn := fake.getSSHPasscodeReturnsOnCall[len(fake.getSSHPasscodeArgsForCall)]
	fake.getSSHPasscodeArgsForCall = append(fake.getSSHPasscodeArgsForCall, struct {
	}{})
	fake.recordInvocation("GetSSHPasscode", []interface{}{})
	fake.getSSHPasscodeMutex.Unlock()
	if fake.GetSSHPasscodeStub != nil {
		return fake.GetSSHPasscodeStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getSSHPasscodeReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetSSHPasscodeCallCount() int {
	fake.getSSHPasscodeMutex.RLock()
	defer fake.getSSHPasscodeMutex.RUnlock()
	return len(fake.getSSHPasscodeArgsForCall)
}

func (fake *FakeActor) GetSSHPasscodeCalls(stub func() (string, error)) {
	fake.getSSHPasscodeMutex.Lock()
	defer fake.getSSHPasscodeMutex.Unlock()
	fake.GetSSHPasscodeStub = stub
}

func (fake *FakeActor) GetSSHPasscodeReturns(result1 string, result2 error) {
	fake.getSSHPasscodeMutex.Lock()
	defer fake.getSSHPasscodeMutex.Unlock()
	fake.GetSSHPasscodeStub = nil
	fake.getSSHPasscodeReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetSSHPasscodeReturnsOnCall(i int, result1 string, result2 error) {
	fake.getSSHPasscodeMutex.Lock()
	defer fake.getSSHPasscodeMutex.Unlock()
	fake.GetSSHPasscodeStub = nil
	if fake.getSSHPasscodeReturnsOnCall == nil {
		fake.getSSHPasscodeReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.getSSHPasscodeReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndex(arg1 string, arg2 string, arg3 string, arg4 uint) (v7action.SSHAuthentication, v7action.Warnings, error) {
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	ret, specificReturn := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall[len(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall)]
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall = append(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 uint
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndex", []interface{}{arg1, arg2, arg3, arg4})
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	if fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub != nil {
		return fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexCallCount() int {
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RLock()
	defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock()
	return len(fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall)
}

func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexCalls(stub func(string, string, string, uint) (v7action.SSHAuthentication, v7action.Warnings, error)) {
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub = stub
}

func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall(i int) (string, string, string, uint) {
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RLock()
	defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock()
	argsForCall := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns(result1 v7action.SSHAuthentication, result2 v7action.Warnings, result3 error) {
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub = nil
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns = struct {
		result1 v7action.SSHAuthentication
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall(i int, result1 v7action.SSHAuthentication, result2 v7action.Warnings, result3 error) {
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Lock()
	defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub = nil
	if fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall == nil {
		fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall = make(map[int]struct {
			result1 v7action.SSHAuthentication
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturnsOnCall[i] = struct {
		result1 v7action.SSHAuthentication
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSecurityGroup(arg1 string) (resources.SecurityGroup, v7action.Warnings, error) {
	fake.getSecurityGroupMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupReturnsOnCall[len(fake.getSecurityGroupArgsForCall)]
	fake.getSecurityGroupArgsForCall = append(fake.getSecurityGroupArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSecurityGroup", []interface{}{arg1})
	fake.getSecurityGroupMutex.Unlock()
	if fake.GetSecurityGroupStub != nil {
		return fake.GetSecurityGroupStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSecurityGroupReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSecurityGroupCallCount() int {
	fake.getSecurityGroupMutex.RLock()
	defer fake.getSecurityGroupMutex.RUnlock()
	return len(fake.getSecurityGroupArgsForCall)
}

func (fake *FakeActor) GetSecurityGroupCalls(stub func(string) (resources.SecurityGroup, v7action.Warnings, error)) {
	fake.getSecurityGroupMutex.Lock()
	defer fake.getSecurityGroupMutex.Unlock()
	fake.GetSecurityGroupStub = stub
}

func (fake *FakeActor) GetSecurityGroupArgsForCall(i int) string {
	fake.getSecurityGroupMutex.RLock()
	defer fake.getSecurityGroupMutex.RUnlock()
	argsForCall := fake.getSecurityGroupArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetSecurityGroupReturns(result1 resources.SecurityGroup, result2 v7action.Warnings, result3 error) {
	fake.getSecurityGroupMutex.Lock()
	defer fake.getSecurityGroupMutex.Unlock()
	fake.GetSecurityGroupStub = nil
	fake.getSecurityGroupReturns = struct {
		result1 resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSecurityGroupReturnsOnCall(i int, result1 resources.SecurityGroup, result2 v7action.Warnings, result3 error) {
	fake.getSecurityGroupMutex.Lock()
	defer fake.getSecurityGroupMutex.Unlock()
	fake.GetSecurityGroupStub = nil
	if fake.getSecurityGroupReturnsOnCall == nil {
		fake.getSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 resources.SecurityGroup
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupReturnsOnCall[i] = struct {
		result1 resources.SecurityGroup
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSecurityGroupSummary(arg1 string) (v7action.SecurityGroupSummary, v7action.Warnings, error) {
	fake.getSecurityGroupSummaryMutex.Lock()
	ret, specificReturn := fake.getSecurityGroupSummaryReturnsOnCall[len(fake.getSecurityGroupSummaryArgsForCall)]
	fake.getSecurityGroupSummaryArgsForCall = append(fake.getSecurityGroupSummaryArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSecurityGroupSummary", []interface{}{arg1})
	fake.getSecurityGroupSummaryMutex.Unlock()
	if fake.GetSecurityGroupSummaryStub != nil {
		return fake.GetSecurityGroupSummaryStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSecurityGroupSummaryReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSecurityGroupSummaryCallCount() int {
	fake.getSecurityGroupSummaryMutex.RLock()
	defer fake.getSecurityGroupSummaryMutex.RUnlock()
	return len(fake.getSecurityGroupSummaryArgsForCall)
}

func (fake *FakeActor) GetSecurityGroupSummaryCalls(stub func(string) (v7action.SecurityGroupSummary, v7action.Warnings, error)) {
	fake.getSecurityGroupSummaryMutex.Lock()
	defer fake.getSecurityGroupSummaryMutex.Unlock()
	fake.GetSecurityGroupSummaryStub = stub
}

func (fake *FakeActor) GetSecurityGroupSummaryArgsForCall(i int) string {
	fake.getSecurityGroupSummaryMutex.RLock()
	defer fake.getSecurityGroupSummaryMutex.RUnlock()
	argsForCall := fake.getSecurityGroupSummaryArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetSecurityGroupSummaryReturns(result1 v7action.SecurityGroupSummary, result2 v7action.Warnings, result3 error) {
	fake.getSecurityGroupSummaryMutex.Lock()
	defer fake.getSecurityGroupSummaryMutex.Unlock()
	fake.GetSecurityGroupSummaryStub = nil
	fake.getSecurityGroupSummaryReturns = struct {
		result1 v7action.SecurityGroupSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSecurityGroupSummaryReturnsOnCall(i int, result1 v7action.SecurityGroupSummary, result2 v7action.Warnings, result3 error) {
	fake.getSecurityGroupSummaryMutex.Lock()
	defer fake.getSecurityGroupSummaryMutex.Unlock()
	fake.GetSecurityGroupSummaryStub = nil
	if fake.getSecurityGroupSummaryReturnsOnCall == nil {
		fake.getSecurityGroupSummaryReturnsOnCall = make(map[int]struct {
			result1 v7action.SecurityGroupSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSecurityGroupSummaryReturnsOnCall[i] = struct {
		result1 v7action.SecurityGroupSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeActor) GetSecurityGroupsCalls(stub func() ([]v7action.SecurityGroupSummary, v7action.Warnings, error)) {
	fake.getSecurityGroupsMutex.Lock()
	defer fake.getSecurityGroupsMutex.Unlock()
	fake.GetSecurityGroupsStub = stub
}

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

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

func (fake *FakeActor) GetServiceAccess(arg1 string, arg2 string, arg3 string) ([]v7action.ServicePlanAccess, v7action.Warnings, error) {
	fake.getServiceAccessMutex.Lock()
	ret, specificReturn := fake.getServiceAccessReturnsOnCall[len(fake.getServiceAccessArgsForCall)]
	fake.getServiceAccessArgsForCall = append(fake.getServiceAccessArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetServiceAccess", []interface{}{arg1, arg2, arg3})
	fake.getServiceAccessMutex.Unlock()
	if fake.GetServiceAccessStub != nil {
		return fake.GetServiceAccessStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceAccessReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceAccessCallCount() int {
	fake.getServiceAccessMutex.RLock()
	defer fake.getServiceAccessMutex.RUnlock()
	return len(fake.getServiceAccessArgsForCall)
}

func (fake *FakeActor) GetServiceAccessCalls(stub func(string, string, string) ([]v7action.ServicePlanAccess, v7action.Warnings, error)) {
	fake.getServiceAccessMutex.Lock()
	defer fake.getServiceAccessMutex.Unlock()
	fake.GetServiceAccessStub = stub
}

func (fake *FakeActor) GetServiceAccessArgsForCall(i int) (string, string, string) {
	fake.getServiceAccessMutex.RLock()
	defer fake.getServiceAccessMutex.RUnlock()
	argsForCall := fake.getServiceAccessArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetServiceAccessReturns(result1 []v7action.ServicePlanAccess, result2 v7action.Warnings, result3 error) {
	fake.getServiceAccessMutex.Lock()
	defer fake.getServiceAccessMutex.Unlock()
	fake.GetServiceAccessStub = nil
	fake.getServiceAccessReturns = struct {
		result1 []v7action.ServicePlanAccess
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceAccessReturnsOnCall(i int, result1 []v7action.ServicePlanAccess, result2 v7action.Warnings, result3 error) {
	fake.getServiceAccessMutex.Lock()
	defer fake.getServiceAccessMutex.Unlock()
	fake.GetServiceAccessStub = nil
	if fake.getServiceAccessReturnsOnCall == nil {
		fake.getServiceAccessReturnsOnCall = make(map[int]struct {
			result1 []v7action.ServicePlanAccess
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceAccessReturnsOnCall[i] = struct {
		result1 []v7action.ServicePlanAccess
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceBrokerByName(arg1 string) (resources.ServiceBroker, v7action.Warnings, error) {
	fake.getServiceBrokerByNameMutex.Lock()
	ret, specificReturn := fake.getServiceBrokerByNameReturnsOnCall[len(fake.getServiceBrokerByNameArgsForCall)]
	fake.getServiceBrokerByNameArgsForCall = append(fake.getServiceBrokerByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceBrokerByName", []interface{}{arg1})
	fake.getServiceBrokerByNameMutex.Unlock()
	if fake.GetServiceBrokerByNameStub != nil {
		return fake.GetServiceBrokerByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceBrokerByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceBrokerByNameCallCount() int {
	fake.getServiceBrokerByNameMutex.RLock()
	defer fake.getServiceBrokerByNameMutex.RUnlock()
	return len(fake.getServiceBrokerByNameArgsForCall)
}

func (fake *FakeActor) GetServiceBrokerByNameCalls(stub func(string) (resources.ServiceBroker, v7action.Warnings, error)) {
	fake.getServiceBrokerByNameMutex.Lock()
	defer fake.getServiceBrokerByNameMutex.Unlock()
	fake.GetServiceBrokerByNameStub = stub
}

func (fake *FakeActor) GetServiceBrokerByNameArgsForCall(i int) string {
	fake.getServiceBrokerByNameMutex.RLock()
	defer fake.getServiceBrokerByNameMutex.RUnlock()
	argsForCall := fake.getServiceBrokerByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetServiceBrokerByNameReturns(result1 resources.ServiceBroker, result2 v7action.Warnings, result3 error) {
	fake.getServiceBrokerByNameMutex.Lock()
	defer fake.getServiceBrokerByNameMutex.Unlock()
	fake.GetServiceBrokerByNameStub = nil
	fake.getServiceBrokerByNameReturns = struct {
		result1 resources.ServiceBroker
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceBrokerByNameReturnsOnCall(i int, result1 resources.ServiceBroker, result2 v7action.Warnings, result3 error) {
	fake.getServiceBrokerByNameMutex.Lock()
	defer fake.getServiceBrokerByNameMutex.Unlock()
	fake.GetServiceBrokerByNameStub = nil
	if fake.getServiceBrokerByNameReturnsOnCall == nil {
		fake.getServiceBrokerByNameReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceBroker
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceBrokerByNameReturnsOnCall[i] = struct {
		result1 resources.ServiceBroker
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceBrokerLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getServiceBrokerLabelsMutex.Lock()
	ret, specificReturn := fake.getServiceBrokerLabelsReturnsOnCall[len(fake.getServiceBrokerLabelsArgsForCall)]
	fake.getServiceBrokerLabelsArgsForCall = append(fake.getServiceBrokerLabelsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetServiceBrokerLabels", []interface{}{arg1})
	fake.getServiceBrokerLabelsMutex.Unlock()
	if fake.GetServiceBrokerLabelsStub != nil {
		return fake.GetServiceBrokerLabelsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceBrokerLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceBrokerLabelsCallCount() int {
	fake.getServiceBrokerLabelsMutex.RLock()
	defer fake.getServiceBrokerLabelsMutex.RUnlock()
	return len(fake.getServiceBrokerLabelsArgsForCall)
}

func (fake *FakeActor) GetServiceBrokerLabelsCalls(stub func(string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getServiceBrokerLabelsMutex.Lock()
	defer fake.getServiceBrokerLabelsMutex.Unlock()
	fake.GetServiceBrokerLabelsStub = stub
}

func (fake *FakeActor) GetServiceBrokerLabelsArgsForCall(i int) string {
	fake.getServiceBrokerLabelsMutex.RLock()
	defer fake.getServiceBrokerLabelsMutex.RUnlock()
	argsForCall := fake.getServiceBrokerLabelsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetServiceBrokerLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServiceBrokerLabelsMutex.Lock()
	defer fake.getServiceBrokerLabelsMutex.Unlock()
	fake.GetServiceBrokerLabelsStub = nil
	fake.getServiceBrokerLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceBrokerLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServiceBrokerLabelsMutex.Lock()
	defer fake.getServiceBrokerLabelsMutex.Unlock()
	fake.GetServiceBrokerLabelsStub = nil
	if fake.getServiceBrokerLabelsReturnsOnCall == nil {
		fake.getServiceBrokerLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceBrokerLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

func (fake *FakeActor) GetServiceBrokersCalls(stub func() ([]resources.ServiceBroker, v7action.Warnings, error)) {
	fake.getServiceBrokersMutex.Lock()
	defer fake.getServiceBrokersMutex.Unlock()
	fake.GetServiceBrokersStub = stub
}

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

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

func (fake *FakeActor) GetServiceInstanceByNameAndSpace(arg1 string, arg2 string) (resources.ServiceInstance, v7action.Warnings, error) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceByNameAndSpaceReturnsOnCall[len(fake.getServiceInstanceByNameAndSpaceArgsForCall)]
	fake.getServiceInstanceByNameAndSpaceArgsForCall = append(fake.getServiceInstanceByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceInstanceByNameAndSpace", []interface{}{arg1, arg2})
	fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	if fake.GetServiceInstanceByNameAndSpaceStub != nil {
		return fake.GetServiceInstanceByNameAndSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceInstanceByNameAndSpaceCallCount() int {
	fake.getServiceInstanceByNameAndSpaceMutex.RLock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock()
	return len(fake.getServiceInstanceByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetServiceInstanceByNameAndSpaceCalls(stub func(string, string) (resources.ServiceInstance, v7action.Warnings, error)) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	fake.GetServiceInstanceByNameAndSpaceStub = stub
}

func (fake *FakeActor) GetServiceInstanceByNameAndSpaceArgsForCall(i int) (string, string) {
	fake.getServiceInstanceByNameAndSpaceMutex.RLock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getServiceInstanceByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetServiceInstanceByNameAndSpaceReturns(result1 resources.ServiceInstance, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	fake.GetServiceInstanceByNameAndSpaceStub = nil
	fake.getServiceInstanceByNameAndSpaceReturns = struct {
		result1 resources.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceByNameAndSpaceReturnsOnCall(i int, result1 resources.ServiceInstance, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceByNameAndSpaceMutex.Lock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	fake.GetServiceInstanceByNameAndSpaceStub = nil
	if fake.getServiceInstanceByNameAndSpaceReturnsOnCall == nil {
		fake.getServiceInstanceByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceInstance
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceByNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceDetails(arg1 string, arg2 string, arg3 bool) (v7action.ServiceInstanceDetails, v7action.Warnings, error) {
	fake.getServiceInstanceDetailsMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceDetailsReturnsOnCall[len(fake.getServiceInstanceDetailsArgsForCall)]
	fake.getServiceInstanceDetailsArgsForCall = append(fake.getServiceInstanceDetailsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetServiceInstanceDetails", []interface{}{arg1, arg2, arg3})
	fake.getServiceInstanceDetailsMutex.Unlock()
	if fake.GetServiceInstanceDetailsStub != nil {
		return fake.GetServiceInstanceDetailsStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceDetailsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceInstanceDetailsCallCount() int {
	fake.getServiceInstanceDetailsMutex.RLock()
	defer fake.getServiceInstanceDetailsMutex.RUnlock()
	return len(fake.getServiceInstanceDetailsArgsForCall)
}

func (fake *FakeActor) GetServiceInstanceDetailsCalls(stub func(string, string, bool) (v7action.ServiceInstanceDetails, v7action.Warnings, error)) {
	fake.getServiceInstanceDetailsMutex.Lock()
	defer fake.getServiceInstanceDetailsMutex.Unlock()
	fake.GetServiceInstanceDetailsStub = stub
}

func (fake *FakeActor) GetServiceInstanceDetailsArgsForCall(i int) (string, string, bool) {
	fake.getServiceInstanceDetailsMutex.RLock()
	defer fake.getServiceInstanceDetailsMutex.RUnlock()
	argsForCall := fake.getServiceInstanceDetailsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetServiceInstanceDetailsReturns(result1 v7action.ServiceInstanceDetails, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceDetailsMutex.Lock()
	defer fake.getServiceInstanceDetailsMutex.Unlock()
	fake.GetServiceInstanceDetailsStub = nil
	fake.getServiceInstanceDetailsReturns = struct {
		result1 v7action.ServiceInstanceDetails
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceDetailsReturnsOnCall(i int, result1 v7action.ServiceInstanceDetails, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceDetailsMutex.Lock()
	defer fake.getServiceInstanceDetailsMutex.Unlock()
	fake.GetServiceInstanceDetailsStub = nil
	if fake.getServiceInstanceDetailsReturnsOnCall == nil {
		fake.getServiceInstanceDetailsReturnsOnCall = make(map[int]struct {
			result1 v7action.ServiceInstanceDetails
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceDetailsReturnsOnCall[i] = struct {
		result1 v7action.ServiceInstanceDetails
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getServiceInstanceLabelsMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceLabelsReturnsOnCall[len(fake.getServiceInstanceLabelsArgsForCall)]
	fake.getServiceInstanceLabelsArgsForCall = append(fake.getServiceInstanceLabelsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceInstanceLabels", []interface{}{arg1, arg2})
	fake.getServiceInstanceLabelsMutex.Unlock()
	if fake.GetServiceInstanceLabelsStub != nil {
		return fake.GetServiceInstanceLabelsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceInstanceLabelsCallCount() int {
	fake.getServiceInstanceLabelsMutex.RLock()
	defer fake.getServiceInstanceLabelsMutex.RUnlock()
	return len(fake.getServiceInstanceLabelsArgsForCall)
}

func (fake *FakeActor) GetServiceInstanceLabelsCalls(stub func(string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getServiceInstanceLabelsMutex.Lock()
	defer fake.getServiceInstanceLabelsMutex.Unlock()
	fake.GetServiceInstanceLabelsStub = stub
}

func (fake *FakeActor) GetServiceInstanceLabelsArgsForCall(i int) (string, string) {
	fake.getServiceInstanceLabelsMutex.RLock()
	defer fake.getServiceInstanceLabelsMutex.RUnlock()
	argsForCall := fake.getServiceInstanceLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetServiceInstanceLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceLabelsMutex.Lock()
	defer fake.getServiceInstanceLabelsMutex.Unlock()
	fake.GetServiceInstanceLabelsStub = nil
	fake.getServiceInstanceLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceLabelsMutex.Lock()
	defer fake.getServiceInstanceLabelsMutex.Unlock()
	fake.GetServiceInstanceLabelsStub = nil
	if fake.getServiceInstanceLabelsReturnsOnCall == nil {
		fake.getServiceInstanceLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceParameters(arg1 string, arg2 string) (v7action.ServiceInstanceParameters, v7action.Warnings, error) {
	fake.getServiceInstanceParametersMutex.Lock()
	ret, specificReturn := fake.getServiceInstanceParametersReturnsOnCall[len(fake.getServiceInstanceParametersArgsForCall)]
	fake.getServiceInstanceParametersArgsForCall = append(fake.getServiceInstanceParametersArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceInstanceParameters", []interface{}{arg1, arg2})
	fake.getServiceInstanceParametersMutex.Unlock()
	if fake.GetServiceInstanceParametersStub != nil {
		return fake.GetServiceInstanceParametersStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstanceParametersReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceInstanceParametersCallCount() int {
	fake.getServiceInstanceParametersMutex.RLock()
	defer fake.getServiceInstanceParametersMutex.RUnlock()
	return len(fake.getServiceInstanceParametersArgsForCall)
}

func (fake *FakeActor) GetServiceInstanceParametersCalls(stub func(string, string) (v7action.ServiceInstanceParameters, v7action.Warnings, error)) {
	fake.getServiceInstanceParametersMutex.Lock()
	defer fake.getServiceInstanceParametersMutex.Unlock()
	fake.GetServiceInstanceParametersStub = stub
}

func (fake *FakeActor) GetServiceInstanceParametersArgsForCall(i int) (string, string) {
	fake.getServiceInstanceParametersMutex.RLock()
	defer fake.getServiceInstanceParametersMutex.RUnlock()
	argsForCall := fake.getServiceInstanceParametersArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetServiceInstanceParametersReturns(result1 v7action.ServiceInstanceParameters, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceParametersMutex.Lock()
	defer fake.getServiceInstanceParametersMutex.Unlock()
	fake.GetServiceInstanceParametersStub = nil
	fake.getServiceInstanceParametersReturns = struct {
		result1 v7action.ServiceInstanceParameters
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstanceParametersReturnsOnCall(i int, result1 v7action.ServiceInstanceParameters, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstanceParametersMutex.Lock()
	defer fake.getServiceInstanceParametersMutex.Unlock()
	fake.GetServiceInstanceParametersStub = nil
	if fake.getServiceInstanceParametersReturnsOnCall == nil {
		fake.getServiceInstanceParametersReturnsOnCall = make(map[int]struct {
			result1 v7action.ServiceInstanceParameters
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceInstanceParametersReturnsOnCall[i] = struct {
		result1 v7action.ServiceInstanceParameters
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstancesForSpace(arg1 string, arg2 bool) ([]v7action.ServiceInstance, v7action.Warnings, error) {
	fake.getServiceInstancesForSpaceMutex.Lock()
	ret, specificReturn := fake.getServiceInstancesForSpaceReturnsOnCall[len(fake.getServiceInstancesForSpaceArgsForCall)]
	fake.getServiceInstancesForSpaceArgsForCall = append(fake.getServiceInstancesForSpaceArgsForCall, struct {
		arg1 string
		arg2 bool
	}{arg1, arg2})
	fake.recordInvocation("GetServiceInstancesForSpace", []interface{}{arg1, arg2})
	fake.getServiceInstancesForSpaceMutex.Unlock()
	if fake.GetServiceInstancesForSpaceStub != nil {
		return fake.GetServiceInstancesForSpaceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceInstancesForSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceInstancesForSpaceCallCount() int {
	fake.getServiceInstancesForSpaceMutex.RLock()
	defer fake.getServiceInstancesForSpaceMutex.RUnlock()
	return len(fake.getServiceInstancesForSpaceArgsForCall)
}

func (fake *FakeActor) GetServiceInstancesForSpaceCalls(stub func(string, bool) ([]v7action.ServiceInstance, v7action.Warnings, error)) {
	fake.getServiceInstancesForSpaceMutex.Lock()
	defer fake.getServiceInstancesForSpaceMutex.Unlock()
	fake.GetServiceInstancesForSpaceStub = stub
}

func (fake *FakeActor) GetServiceInstancesForSpaceArgsForCall(i int) (string, bool) {
	fake.getServiceInstancesForSpaceMutex.RLock()
	defer fake.getServiceInstancesForSpaceMutex.RUnlock()
	argsForCall := fake.getServiceInstancesForSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetServiceInstancesForSpaceReturns(result1 []v7action.ServiceInstance, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstancesForSpaceMutex.Lock()
	defer fake.getServiceInstancesForSpaceMutex.Unlock()
	fake.GetServiceInstancesForSpaceStub = nil
	fake.getServiceInstancesForSpaceReturns = struct {
		result1 []v7action.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceInstancesForSpaceReturnsOnCall(i int, result1 []v7action.ServiceInstance, result2 v7action.Warnings, result3 error) {
	fake.getServiceInstancesForSpaceMutex.Lock()
	defer fake.getServiceInstancesForSpaceMutex.Unlock()
	fake.GetServiceInstancesForSpaceStub = nil
	if fake.getServiceInstancesForSpaceReturnsOnCall == nil {
		fake.getServiceInstancesForSpaceReturnsOnCall = make(map[int]struct {
			result1 []v7action.ServiceInstance
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceInstancesForSpaceReturnsOnCall[i] = struct {
		result1 []v7action.ServiceInstance
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceKeyByServiceInstanceAndName(arg1 string, arg2 string, arg3 string) (resources.ServiceCredentialBinding, v7action.Warnings, error) {
	fake.getServiceKeyByServiceInstanceAndNameMutex.Lock()
	ret, specificReturn := fake.getServiceKeyByServiceInstanceAndNameReturnsOnCall[len(fake.getServiceKeyByServiceInstanceAndNameArgsForCall)]
	fake.getServiceKeyByServiceInstanceAndNameArgsForCall = append(fake.getServiceKeyByServiceInstanceAndNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetServiceKeyByServiceInstanceAndName", []interface{}{arg1, arg2, arg3})
	fake.getServiceKeyByServiceInstanceAndNameMutex.Unlock()
	if fake.GetServiceKeyByServiceInstanceAndNameStub != nil {
		return fake.GetServiceKeyByServiceInstanceAndNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceKeyByServiceInstanceAndNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameCallCount() int {
	fake.getServiceKeyByServiceInstanceAndNameMutex.RLock()
	defer fake.getServiceKeyByServiceInstanceAndNameMutex.RUnlock()
	return len(fake.getServiceKeyByServiceInstanceAndNameArgsForCall)
}

func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameCalls(stub func(string, string, string) (resources.ServiceCredentialBinding, v7action.Warnings, error)) {
	fake.getServiceKeyByServiceInstanceAndNameMutex.Lock()
	defer fake.getServiceKeyByServiceInstanceAndNameMutex.Unlock()
	fake.GetServiceKeyByServiceInstanceAndNameStub = stub
}

func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameArgsForCall(i int) (string, string, string) {
	fake.getServiceKeyByServiceInstanceAndNameMutex.RLock()
	defer fake.getServiceKeyByServiceInstanceAndNameMutex.RUnlock()
	argsForCall := fake.getServiceKeyByServiceInstanceAndNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameReturns(result1 resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) {
	fake.getServiceKeyByServiceInstanceAndNameMutex.Lock()
	defer fake.getServiceKeyByServiceInstanceAndNameMutex.Unlock()
	fake.GetServiceKeyByServiceInstanceAndNameStub = nil
	fake.getServiceKeyByServiceInstanceAndNameReturns = struct {
		result1 resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceKeyByServiceInstanceAndNameReturnsOnCall(i int, result1 resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) {
	fake.getServiceKeyByServiceInstanceAndNameMutex.Lock()
	defer fake.getServiceKeyByServiceInstanceAndNameMutex.Unlock()
	fake.GetServiceKeyByServiceInstanceAndNameStub = nil
	if fake.getServiceKeyByServiceInstanceAndNameReturnsOnCall == nil {
		fake.getServiceKeyByServiceInstanceAndNameReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceCredentialBinding
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceKeyByServiceInstanceAndNameReturnsOnCall[i] = struct {
		result1 resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndName(arg1 string, arg2 string, arg3 string) (resources.ServiceCredentialBindingDetails, v7action.Warnings, error) {
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Lock()
	ret, specificReturn := fake.getServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall[len(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall)]
	fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall = append(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetServiceKeyDetailsByServiceInstanceAndName", []interface{}{arg1, arg2, arg3})
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Unlock()
	if fake.GetServiceKeyDetailsByServiceInstanceAndNameStub != nil {
		return fake.GetServiceKeyDetailsByServiceInstanceAndNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceKeyDetailsByServiceInstanceAndNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameCallCount() int {
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RLock()
	defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RUnlock()
	return len(fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall)
}

func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameCalls(stub func(string, string, string) (resources.ServiceCredentialBindingDetails, v7action.Warnings, error)) {
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Lock()
	defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Unlock()
	fake.GetServiceKeyDetailsByServiceInstanceAndNameStub = stub
}

func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameArgsForCall(i int) (string, string, string) {
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RLock()
	defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RUnlock()
	argsForCall := fake.getServiceKeyDetailsByServiceInstanceAndNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameReturns(result1 resources.ServiceCredentialBindingDetails, result2 v7action.Warnings, result3 error) {
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Lock()
	defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Unlock()
	fake.GetServiceKeyDetailsByServiceInstanceAndNameStub = nil
	fake.getServiceKeyDetailsByServiceInstanceAndNameReturns = struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall(i int, result1 resources.ServiceCredentialBindingDetails, result2 v7action.Warnings, result3 error) {
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Lock()
	defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Unlock()
	fake.GetServiceKeyDetailsByServiceInstanceAndNameStub = nil
	if fake.getServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall == nil {
		fake.getServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall = make(map[int]struct {
			result1 resources.ServiceCredentialBindingDetails
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceKeyDetailsByServiceInstanceAndNameReturnsOnCall[i] = struct {
		result1 resources.ServiceCredentialBindingDetails
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceKeysByServiceInstance(arg1 string, arg2 string) ([]resources.ServiceCredentialBinding, v7action.Warnings, error) {
	fake.getServiceKeysByServiceInstanceMutex.Lock()
	ret, specificReturn := fake.getServiceKeysByServiceInstanceReturnsOnCall[len(fake.getServiceKeysByServiceInstanceArgsForCall)]
	fake.getServiceKeysByServiceInstanceArgsForCall = append(fake.getServiceKeysByServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceKeysByServiceInstance", []interface{}{arg1, arg2})
	fake.getServiceKeysByServiceInstanceMutex.Unlock()
	if fake.GetServiceKeysByServiceInstanceStub != nil {
		return fake.GetServiceKeysByServiceInstanceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceKeysByServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceKeysByServiceInstanceCallCount() int {
	fake.getServiceKeysByServiceInstanceMutex.RLock()
	defer fake.getServiceKeysByServiceInstanceMutex.RUnlock()
	return len(fake.getServiceKeysByServiceInstanceArgsForCall)
}

func (fake *FakeActor) GetServiceKeysByServiceInstanceCalls(stub func(string, string) ([]resources.ServiceCredentialBinding, v7action.Warnings, error)) {
	fake.getServiceKeysByServiceInstanceMutex.Lock()
	defer fake.getServiceKeysByServiceInstanceMutex.Unlock()
	fake.GetServiceKeysByServiceInstanceStub = stub
}

func (fake *FakeActor) GetServiceKeysByServiceInstanceArgsForCall(i int) (string, string) {
	fake.getServiceKeysByServiceInstanceMutex.RLock()
	defer fake.getServiceKeysByServiceInstanceMutex.RUnlock()
	argsForCall := fake.getServiceKeysByServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetServiceKeysByServiceInstanceReturns(result1 []resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) {
	fake.getServiceKeysByServiceInstanceMutex.Lock()
	defer fake.getServiceKeysByServiceInstanceMutex.Unlock()
	fake.GetServiceKeysByServiceInstanceStub = nil
	fake.getServiceKeysByServiceInstanceReturns = struct {
		result1 []resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceKeysByServiceInstanceReturnsOnCall(i int, result1 []resources.ServiceCredentialBinding, result2 v7action.Warnings, result3 error) {
	fake.getServiceKeysByServiceInstanceMutex.Lock()
	defer fake.getServiceKeysByServiceInstanceMutex.Unlock()
	fake.GetServiceKeysByServiceInstanceStub = nil
	if fake.getServiceKeysByServiceInstanceReturnsOnCall == nil {
		fake.getServiceKeysByServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 []resources.ServiceCredentialBinding
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceKeysByServiceInstanceReturnsOnCall[i] = struct {
		result1 []resources.ServiceCredentialBinding
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceOfferingLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getServiceOfferingLabelsMutex.Lock()
	ret, specificReturn := fake.getServiceOfferingLabelsReturnsOnCall[len(fake.getServiceOfferingLabelsArgsForCall)]
	fake.getServiceOfferingLabelsArgsForCall = append(fake.getServiceOfferingLabelsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetServiceOfferingLabels", []interface{}{arg1, arg2})
	fake.getServiceOfferingLabelsMutex.Unlock()
	if fake.GetServiceOfferingLabelsStub != nil {
		return fake.GetServiceOfferingLabelsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServiceOfferingLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServiceOfferingLabelsCallCount() int {
	fake.getServiceOfferingLabelsMutex.RLock()
	defer fake.getServiceOfferingLabelsMutex.RUnlock()
	return len(fake.getServiceOfferingLabelsArgsForCall)
}

func (fake *FakeActor) GetServiceOfferingLabelsCalls(stub func(string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getServiceOfferingLabelsMutex.Lock()
	defer fake.getServiceOfferingLabelsMutex.Unlock()
	fake.GetServiceOfferingLabelsStub = stub
}

func (fake *FakeActor) GetServiceOfferingLabelsArgsForCall(i int) (string, string) {
	fake.getServiceOfferingLabelsMutex.RLock()
	defer fake.getServiceOfferingLabelsMutex.RUnlock()
	argsForCall := fake.getServiceOfferingLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetServiceOfferingLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServiceOfferingLabelsMutex.Lock()
	defer fake.getServiceOfferingLabelsMutex.Unlock()
	fake.GetServiceOfferingLabelsStub = nil
	fake.getServiceOfferingLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServiceOfferingLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServiceOfferingLabelsMutex.Lock()
	defer fake.getServiceOfferingLabelsMutex.Unlock()
	fake.GetServiceOfferingLabelsStub = nil
	if fake.getServiceOfferingLabelsReturnsOnCall == nil {
		fake.getServiceOfferingLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServiceOfferingLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServicePlanByNameOfferingAndBroker(arg1 string, arg2 string, arg3 string) (resources.ServicePlan, v7action.Warnings, error) {
	fake.getServicePlanByNameOfferingAndBrokerMutex.Lock()
	ret, specificReturn := fake.getServicePlanByNameOfferingAndBrokerReturnsOnCall[len(fake.getServicePlanByNameOfferingAndBrokerArgsForCall)]
	fake.getServicePlanByNameOfferingAndBrokerArgsForCall = append(fake.getServicePlanByNameOfferingAndBrokerArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetServicePlanByNameOfferingAndBroker", []interface{}{arg1, arg2, arg3})
	fake.getServicePlanByNameOfferingAndBrokerMutex.Unlock()
	if fake.GetServicePlanByNameOfferingAndBrokerStub != nil {
		return fake.GetServicePlanByNameOfferingAndBrokerStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServicePlanByNameOfferingAndBrokerReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerCallCount() int {
	fake.getServicePlanByNameOfferingAndBrokerMutex.RLock()
	defer fake.getServicePlanByNameOfferingAndBrokerMutex.RUnlock()
	return len(fake.getServicePlanByNameOfferingAndBrokerArgsForCall)
}

func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerCalls(stub func(string, string, string) (resources.ServicePlan, v7action.Warnings, error)) {
	fake.getServicePlanByNameOfferingAndBrokerMutex.Lock()
	defer fake.getServicePlanByNameOfferingAndBrokerMutex.Unlock()
	fake.GetServicePlanByNameOfferingAndBrokerStub = stub
}

func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerArgsForCall(i int) (string, string, string) {
	fake.getServicePlanByNameOfferingAndBrokerMutex.RLock()
	defer fake.getServicePlanByNameOfferingAndBrokerMutex.RUnlock()
	argsForCall := fake.getServicePlanByNameOfferingAndBrokerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerReturns(result1 resources.ServicePlan, result2 v7action.Warnings, result3 error) {
	fake.getServicePlanByNameOfferingAndBrokerMutex.Lock()
	defer fake.getServicePlanByNameOfferingAndBrokerMutex.Unlock()
	fake.GetServicePlanByNameOfferingAndBrokerStub = nil
	fake.getServicePlanByNameOfferingAndBrokerReturns = struct {
		result1 resources.ServicePlan
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServicePlanByNameOfferingAndBrokerReturnsOnCall(i int, result1 resources.ServicePlan, result2 v7action.Warnings, result3 error) {
	fake.getServicePlanByNameOfferingAndBrokerMutex.Lock()
	defer fake.getServicePlanByNameOfferingAndBrokerMutex.Unlock()
	fake.GetServicePlanByNameOfferingAndBrokerStub = nil
	if fake.getServicePlanByNameOfferingAndBrokerReturnsOnCall == nil {
		fake.getServicePlanByNameOfferingAndBrokerReturnsOnCall = make(map[int]struct {
			result1 resources.ServicePlan
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServicePlanByNameOfferingAndBrokerReturnsOnCall[i] = struct {
		result1 resources.ServicePlan
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServicePlanLabels(arg1 string, arg2 string, arg3 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getServicePlanLabelsMutex.Lock()
	ret, specificReturn := fake.getServicePlanLabelsReturnsOnCall[len(fake.getServicePlanLabelsArgsForCall)]
	fake.getServicePlanLabelsArgsForCall = append(fake.getServicePlanLabelsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetServicePlanLabels", []interface{}{arg1, arg2, arg3})
	fake.getServicePlanLabelsMutex.Unlock()
	if fake.GetServicePlanLabelsStub != nil {
		return fake.GetServicePlanLabelsStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getServicePlanLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetServicePlanLabelsCallCount() int {
	fake.getServicePlanLabelsMutex.RLock()
	defer fake.getServicePlanLabelsMutex.RUnlock()
	return len(fake.getServicePlanLabelsArgsForCall)
}

func (fake *FakeActor) GetServicePlanLabelsCalls(stub func(string, string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getServicePlanLabelsMutex.Lock()
	defer fake.getServicePlanLabelsMutex.Unlock()
	fake.GetServicePlanLabelsStub = stub
}

func (fake *FakeActor) GetServicePlanLabelsArgsForCall(i int) (string, string, string) {
	fake.getServicePlanLabelsMutex.RLock()
	defer fake.getServicePlanLabelsMutex.RUnlock()
	argsForCall := fake.getServicePlanLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetServicePlanLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServicePlanLabelsMutex.Lock()
	defer fake.getServicePlanLabelsMutex.Unlock()
	fake.GetServicePlanLabelsStub = nil
	fake.getServicePlanLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetServicePlanLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getServicePlanLabelsMutex.Lock()
	defer fake.getServicePlanLabelsMutex.Unlock()
	fake.GetServicePlanLabelsStub = nil
	if fake.getServicePlanLabelsReturnsOnCall == nil {
		fake.getServicePlanLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getServicePlanLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceByNameAndOrganization(arg1 string, arg2 string) (resources.Space, v7action.Warnings, error) {
	fake.getSpaceByNameAndOrganizationMutex.Lock()
	ret, specificReturn := fake.getSpaceByNameAndOrganizationReturnsOnCall[len(fake.getSpaceByNameAndOrganizationArgsForCall)]
	fake.getSpaceByNameAndOrganizationArgsForCall = append(fake.getSpaceByNameAndOrganizationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceByNameAndOrganization", []interface{}{arg1, arg2})
	fake.getSpaceByNameAndOrganizationMutex.Unlock()
	if fake.GetSpaceByNameAndOrganizationStub != nil {
		return fake.GetSpaceByNameAndOrganizationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceByNameAndOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceByNameAndOrganizationCallCount() int {
	fake.getSpaceByNameAndOrganizationMutex.RLock()
	defer fake.getSpaceByNameAndOrganizationMutex.RUnlock()
	return len(fake.getSpaceByNameAndOrganizationArgsForCall)
}

func (fake *FakeActor) GetSpaceByNameAndOrganizationCalls(stub func(string, string) (resources.Space, v7action.Warnings, error)) {
	fake.getSpaceByNameAndOrganizationMutex.Lock()
	defer fake.getSpaceByNameAndOrganizationMutex.Unlock()
	fake.GetSpaceByNameAndOrganizationStub = stub
}

func (fake *FakeActor) GetSpaceByNameAndOrganizationArgsForCall(i int) (string, string) {
	fake.getSpaceByNameAndOrganizationMutex.RLock()
	defer fake.getSpaceByNameAndOrganizationMutex.RUnlock()
	argsForCall := fake.getSpaceByNameAndOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetSpaceByNameAndOrganizationReturns(result1 resources.Space, result2 v7action.Warnings, result3 error) {
	fake.getSpaceByNameAndOrganizationMutex.Lock()
	defer fake.getSpaceByNameAndOrganizationMutex.Unlock()
	fake.GetSpaceByNameAndOrganizationStub = nil
	fake.getSpaceByNameAndOrganizationReturns = struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceByNameAndOrganizationReturnsOnCall(i int, result1 resources.Space, result2 v7action.Warnings, result3 error) {
	fake.getSpaceByNameAndOrganizationMutex.Lock()
	defer fake.getSpaceByNameAndOrganizationMutex.Unlock()
	fake.GetSpaceByNameAndOrganizationStub = nil
	if fake.getSpaceByNameAndOrganizationReturnsOnCall == nil {
		fake.getSpaceByNameAndOrganizationReturnsOnCall = make(map[int]struct {
			result1 resources.Space
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceByNameAndOrganizationReturnsOnCall[i] = struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceFeature(arg1 string, arg2 string, arg3 string) (bool, v7action.Warnings, error) {
	fake.getSpaceFeatureMutex.Lock()
	ret, specificReturn := fake.getSpaceFeatureReturnsOnCall[len(fake.getSpaceFeatureArgsForCall)]
	fake.getSpaceFeatureArgsForCall = append(fake.getSpaceFeatureArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetSpaceFeature", []interface{}{arg1, arg2, arg3})
	fake.getSpaceFeatureMutex.Unlock()
	if fake.GetSpaceFeatureStub != nil {
		return fake.GetSpaceFeatureStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceFeatureReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceFeatureCallCount() int {
	fake.getSpaceFeatureMutex.RLock()
	defer fake.getSpaceFeatureMutex.RUnlock()
	return len(fake.getSpaceFeatureArgsForCall)
}

func (fake *FakeActor) GetSpaceFeatureCalls(stub func(string, string, string) (bool, v7action.Warnings, error)) {
	fake.getSpaceFeatureMutex.Lock()
	defer fake.getSpaceFeatureMutex.Unlock()
	fake.GetSpaceFeatureStub = stub
}

func (fake *FakeActor) GetSpaceFeatureArgsForCall(i int) (string, string, string) {
	fake.getSpaceFeatureMutex.RLock()
	defer fake.getSpaceFeatureMutex.RUnlock()
	argsForCall := fake.getSpaceFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetSpaceFeatureReturns(result1 bool, result2 v7action.Warnings, result3 error) {
	fake.getSpaceFeatureMutex.Lock()
	defer fake.getSpaceFeatureMutex.Unlock()
	fake.GetSpaceFeatureStub = nil
	fake.getSpaceFeatureReturns = struct {
		result1 bool
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceFeatureReturnsOnCall(i int, result1 bool, result2 v7action.Warnings, result3 error) {
	fake.getSpaceFeatureMutex.Lock()
	defer fake.getSpaceFeatureMutex.Unlock()
	fake.GetSpaceFeatureStub = nil
	if fake.getSpaceFeatureReturnsOnCall == nil {
		fake.getSpaceFeatureReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceFeatureReturnsOnCall[i] = struct {
		result1 bool
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceLabels(arg1 string, arg2 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getSpaceLabelsMutex.Lock()
	ret, specificReturn := fake.getSpaceLabelsReturnsOnCall[len(fake.getSpaceLabelsArgsForCall)]
	fake.getSpaceLabelsArgsForCall = append(fake.getSpaceLabelsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceLabels", []interface{}{arg1, arg2})
	fake.getSpaceLabelsMutex.Unlock()
	if fake.GetSpaceLabelsStub != nil {
		return fake.GetSpaceLabelsStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceLabelsCallCount() int {
	fake.getSpaceLabelsMutex.RLock()
	defer fake.getSpaceLabelsMutex.RUnlock()
	return len(fake.getSpaceLabelsArgsForCall)
}

func (fake *FakeActor) GetSpaceLabelsCalls(stub func(string, string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getSpaceLabelsMutex.Lock()
	defer fake.getSpaceLabelsMutex.Unlock()
	fake.GetSpaceLabelsStub = stub
}

func (fake *FakeActor) GetSpaceLabelsArgsForCall(i int) (string, string) {
	fake.getSpaceLabelsMutex.RLock()
	defer fake.getSpaceLabelsMutex.RUnlock()
	argsForCall := fake.getSpaceLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetSpaceLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getSpaceLabelsMutex.Lock()
	defer fake.getSpaceLabelsMutex.Unlock()
	fake.GetSpaceLabelsStub = nil
	fake.getSpaceLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getSpaceLabelsMutex.Lock()
	defer fake.getSpaceLabelsMutex.Unlock()
	fake.GetSpaceLabelsStub = nil
	if fake.getSpaceLabelsReturnsOnCall == nil {
		fake.getSpaceLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceQuotaByName(arg1 string, arg2 string) (resources.SpaceQuota, v7action.Warnings, error) {
	fake.getSpaceQuotaByNameMutex.Lock()
	ret, specificReturn := fake.getSpaceQuotaByNameReturnsOnCall[len(fake.getSpaceQuotaByNameArgsForCall)]
	fake.getSpaceQuotaByNameArgsForCall = append(fake.getSpaceQuotaByNameArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceQuotaByName", []interface{}{arg1, arg2})
	fake.getSpaceQuotaByNameMutex.Unlock()
	if fake.GetSpaceQuotaByNameStub != nil {
		return fake.GetSpaceQuotaByNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceQuotaByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceQuotaByNameCallCount() int {
	fake.getSpaceQuotaByNameMutex.RLock()
	defer fake.getSpaceQuotaByNameMutex.RUnlock()
	return len(fake.getSpaceQuotaByNameArgsForCall)
}

func (fake *FakeActor) GetSpaceQuotaByNameCalls(stub func(string, string) (resources.SpaceQuota, v7action.Warnings, error)) {
	fake.getSpaceQuotaByNameMutex.Lock()
	defer fake.getSpaceQuotaByNameMutex.Unlock()
	fake.GetSpaceQuotaByNameStub = stub
}

func (fake *FakeActor) GetSpaceQuotaByNameArgsForCall(i int) (string, string) {
	fake.getSpaceQuotaByNameMutex.RLock()
	defer fake.getSpaceQuotaByNameMutex.RUnlock()
	argsForCall := fake.getSpaceQuotaByNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetSpaceQuotaByNameReturns(result1 resources.SpaceQuota, result2 v7action.Warnings, result3 error) {
	fake.getSpaceQuotaByNameMutex.Lock()
	defer fake.getSpaceQuotaByNameMutex.Unlock()
	fake.GetSpaceQuotaByNameStub = nil
	fake.getSpaceQuotaByNameReturns = struct {
		result1 resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceQuotaByNameReturnsOnCall(i int, result1 resources.SpaceQuota, result2 v7action.Warnings, result3 error) {
	fake.getSpaceQuotaByNameMutex.Lock()
	defer fake.getSpaceQuotaByNameMutex.Unlock()
	fake.GetSpaceQuotaByNameStub = nil
	if fake.getSpaceQuotaByNameReturnsOnCall == nil {
		fake.getSpaceQuotaByNameReturnsOnCall = make(map[int]struct {
			result1 resources.SpaceQuota
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotaByNameReturnsOnCall[i] = struct {
		result1 resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceQuotasByOrgGUID(arg1 string) ([]resources.SpaceQuota, v7action.Warnings, error) {
	fake.getSpaceQuotasByOrgGUIDMutex.Lock()
	ret, specificReturn := fake.getSpaceQuotasByOrgGUIDReturnsOnCall[len(fake.getSpaceQuotasByOrgGUIDArgsForCall)]
	fake.getSpaceQuotasByOrgGUIDArgsForCall = append(fake.getSpaceQuotasByOrgGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSpaceQuotasByOrgGUID", []interface{}{arg1})
	fake.getSpaceQuotasByOrgGUIDMutex.Unlock()
	if fake.GetSpaceQuotasByOrgGUIDStub != nil {
		return fake.GetSpaceQuotasByOrgGUIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceQuotasByOrgGUIDReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceQuotasByOrgGUIDCallCount() int {
	fake.getSpaceQuotasByOrgGUIDMutex.RLock()
	defer fake.getSpaceQuotasByOrgGUIDMutex.RUnlock()
	return len(fake.getSpaceQuotasByOrgGUIDArgsForCall)
}

func (fake *FakeActor) GetSpaceQuotasByOrgGUIDCalls(stub func(string) ([]resources.SpaceQuota, v7action.Warnings, error)) {
	fake.getSpaceQuotasByOrgGUIDMutex.Lock()
	defer fake.getSpaceQuotasByOrgGUIDMutex.Unlock()
	fake.GetSpaceQuotasByOrgGUIDStub = stub
}

func (fake *FakeActor) GetSpaceQuotasByOrgGUIDArgsForCall(i int) string {
	fake.getSpaceQuotasByOrgGUIDMutex.RLock()
	defer fake.getSpaceQuotasByOrgGUIDMutex.RUnlock()
	argsForCall := fake.getSpaceQuotasByOrgGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetSpaceQuotasByOrgGUIDReturns(result1 []resources.SpaceQuota, result2 v7action.Warnings, result3 error) {
	fake.getSpaceQuotasByOrgGUIDMutex.Lock()
	defer fake.getSpaceQuotasByOrgGUIDMutex.Unlock()
	fake.GetSpaceQuotasByOrgGUIDStub = nil
	fake.getSpaceQuotasByOrgGUIDReturns = struct {
		result1 []resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceQuotasByOrgGUIDReturnsOnCall(i int, result1 []resources.SpaceQuota, result2 v7action.Warnings, result3 error) {
	fake.getSpaceQuotasByOrgGUIDMutex.Lock()
	defer fake.getSpaceQuotasByOrgGUIDMutex.Unlock()
	fake.GetSpaceQuotasByOrgGUIDStub = nil
	if fake.getSpaceQuotasByOrgGUIDReturnsOnCall == nil {
		fake.getSpaceQuotasByOrgGUIDReturnsOnCall = make(map[int]struct {
			result1 []resources.SpaceQuota
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceQuotasByOrgGUIDReturnsOnCall[i] = struct {
		result1 []resources.SpaceQuota
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceSummaryByNameAndOrganization(arg1 string, arg2 string) (v7action.SpaceSummary, v7action.Warnings, error) {
	fake.getSpaceSummaryByNameAndOrganizationMutex.Lock()
	ret, specificReturn := fake.getSpaceSummaryByNameAndOrganizationReturnsOnCall[len(fake.getSpaceSummaryByNameAndOrganizationArgsForCall)]
	fake.getSpaceSummaryByNameAndOrganizationArgsForCall = append(fake.getSpaceSummaryByNameAndOrganizationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetSpaceSummaryByNameAndOrganization", []interface{}{arg1, arg2})
	fake.getSpaceSummaryByNameAndOrganizationMutex.Unlock()
	if fake.GetSpaceSummaryByNameAndOrganizationStub != nil {
		return fake.GetSpaceSummaryByNameAndOrganizationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceSummaryByNameAndOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationCallCount() int {
	fake.getSpaceSummaryByNameAndOrganizationMutex.RLock()
	defer fake.getSpaceSummaryByNameAndOrganizationMutex.RUnlock()
	return len(fake.getSpaceSummaryByNameAndOrganizationArgsForCall)
}

func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationCalls(stub func(string, string) (v7action.SpaceSummary, v7action.Warnings, error)) {
	fake.getSpaceSummaryByNameAndOrganizationMutex.Lock()
	defer fake.getSpaceSummaryByNameAndOrganizationMutex.Unlock()
	fake.GetSpaceSummaryByNameAndOrganizationStub = stub
}

func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationArgsForCall(i int) (string, string) {
	fake.getSpaceSummaryByNameAndOrganizationMutex.RLock()
	defer fake.getSpaceSummaryByNameAndOrganizationMutex.RUnlock()
	argsForCall := fake.getSpaceSummaryByNameAndOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationReturns(result1 v7action.SpaceSummary, result2 v7action.Warnings, result3 error) {
	fake.getSpaceSummaryByNameAndOrganizationMutex.Lock()
	defer fake.getSpaceSummaryByNameAndOrganizationMutex.Unlock()
	fake.GetSpaceSummaryByNameAndOrganizationStub = nil
	fake.getSpaceSummaryByNameAndOrganizationReturns = struct {
		result1 v7action.SpaceSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceSummaryByNameAndOrganizationReturnsOnCall(i int, result1 v7action.SpaceSummary, result2 v7action.Warnings, result3 error) {
	fake.getSpaceSummaryByNameAndOrganizationMutex.Lock()
	defer fake.getSpaceSummaryByNameAndOrganizationMutex.Unlock()
	fake.GetSpaceSummaryByNameAndOrganizationStub = nil
	if fake.getSpaceSummaryByNameAndOrganizationReturnsOnCall == nil {
		fake.getSpaceSummaryByNameAndOrganizationReturnsOnCall = make(map[int]struct {
			result1 v7action.SpaceSummary
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceSummaryByNameAndOrganizationReturnsOnCall[i] = struct {
		result1 v7action.SpaceSummary
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceUsersByRoleType(arg1 string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error) {
	fake.getSpaceUsersByRoleTypeMutex.Lock()
	ret, specificReturn := fake.getSpaceUsersByRoleTypeReturnsOnCall[len(fake.getSpaceUsersByRoleTypeArgsForCall)]
	fake.getSpaceUsersByRoleTypeArgsForCall = append(fake.getSpaceUsersByRoleTypeArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetSpaceUsersByRoleType", []interface{}{arg1})
	fake.getSpaceUsersByRoleTypeMutex.Unlock()
	if fake.GetSpaceUsersByRoleTypeStub != nil {
		return fake.GetSpaceUsersByRoleTypeStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getSpaceUsersByRoleTypeReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetSpaceUsersByRoleTypeCallCount() int {
	fake.getSpaceUsersByRoleTypeMutex.RLock()
	defer fake.getSpaceUsersByRoleTypeMutex.RUnlock()
	return len(fake.getSpaceUsersByRoleTypeArgsForCall)
}

func (fake *FakeActor) GetSpaceUsersByRoleTypeCalls(stub func(string) (map[constanta.RoleType][]resources.User, v7action.Warnings, error)) {
	fake.getSpaceUsersByRoleTypeMutex.Lock()
	defer fake.getSpaceUsersByRoleTypeMutex.Unlock()
	fake.GetSpaceUsersByRoleTypeStub = stub
}

func (fake *FakeActor) GetSpaceUsersByRoleTypeArgsForCall(i int) string {
	fake.getSpaceUsersByRoleTypeMutex.RLock()
	defer fake.getSpaceUsersByRoleTypeMutex.RUnlock()
	argsForCall := fake.getSpaceUsersByRoleTypeArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetSpaceUsersByRoleTypeReturns(result1 map[constanta.RoleType][]resources.User, result2 v7action.Warnings, result3 error) {
	fake.getSpaceUsersByRoleTypeMutex.Lock()
	defer fake.getSpaceUsersByRoleTypeMutex.Unlock()
	fake.GetSpaceUsersByRoleTypeStub = nil
	fake.getSpaceUsersByRoleTypeReturns = struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetSpaceUsersByRoleTypeReturnsOnCall(i int, result1 map[constanta.RoleType][]resources.User, result2 v7action.Warnings, result3 error) {
	fake.getSpaceUsersByRoleTypeMutex.Lock()
	defer fake.getSpaceUsersByRoleTypeMutex.Unlock()
	fake.GetSpaceUsersByRoleTypeStub = nil
	if fake.getSpaceUsersByRoleTypeReturnsOnCall == nil {
		fake.getSpaceUsersByRoleTypeReturnsOnCall = make(map[int]struct {
			result1 map[constanta.RoleType][]resources.User
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getSpaceUsersByRoleTypeReturnsOnCall[i] = struct {
		result1 map[constanta.RoleType][]resources.User
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetStackByName(arg1 string) (resources.Stack, v7action.Warnings, error) {
	fake.getStackByNameMutex.Lock()
	ret, specificReturn := fake.getStackByNameReturnsOnCall[len(fake.getStackByNameArgsForCall)]
	fake.getStackByNameArgsForCall = append(fake.getStackByNameArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetStackByName", []interface{}{arg1})
	fake.getStackByNameMutex.Unlock()
	if fake.GetStackByNameStub != nil {
		return fake.GetStackByNameStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getStackByNameReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetStackByNameCallCount() int {
	fake.getStackByNameMutex.RLock()
	defer fake.getStackByNameMutex.RUnlock()
	return len(fake.getStackByNameArgsForCall)
}

func (fake *FakeActor) GetStackByNameCalls(stub func(string) (resources.Stack, v7action.Warnings, error)) {
	fake.getStackByNameMutex.Lock()
	defer fake.getStackByNameMutex.Unlock()
	fake.GetStackByNameStub = stub
}

func (fake *FakeActor) GetStackByNameArgsForCall(i int) string {
	fake.getStackByNameMutex.RLock()
	defer fake.getStackByNameMutex.RUnlock()
	argsForCall := fake.getStackByNameArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetStackByNameReturns(result1 resources.Stack, result2 v7action.Warnings, result3 error) {
	fake.getStackByNameMutex.Lock()
	defer fake.getStackByNameMutex.Unlock()
	fake.GetStackByNameStub = nil
	fake.getStackByNameReturns = struct {
		result1 resources.Stack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetStackByNameReturnsOnCall(i int, result1 resources.Stack, result2 v7action.Warnings, result3 error) {
	fake.getStackByNameMutex.Lock()
	defer fake.getStackByNameMutex.Unlock()
	fake.GetStackByNameStub = nil
	if fake.getStackByNameReturnsOnCall == nil {
		fake.getStackByNameReturnsOnCall = make(map[int]struct {
			result1 resources.Stack
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getStackByNameReturnsOnCall[i] = struct {
		result1 resources.Stack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetStackLabels(arg1 string) (map[string]types.NullString, v7action.Warnings, error) {
	fake.getStackLabelsMutex.Lock()
	ret, specificReturn := fake.getStackLabelsReturnsOnCall[len(fake.getStackLabelsArgsForCall)]
	fake.getStackLabelsArgsForCall = append(fake.getStackLabelsArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetStackLabels", []interface{}{arg1})
	fake.getStackLabelsMutex.Unlock()
	if fake.GetStackLabelsStub != nil {
		return fake.GetStackLabelsStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getStackLabelsReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetStackLabelsCallCount() int {
	fake.getStackLabelsMutex.RLock()
	defer fake.getStackLabelsMutex.RUnlock()
	return len(fake.getStackLabelsArgsForCall)
}

func (fake *FakeActor) GetStackLabelsCalls(stub func(string) (map[string]types.NullString, v7action.Warnings, error)) {
	fake.getStackLabelsMutex.Lock()
	defer fake.getStackLabelsMutex.Unlock()
	fake.GetStackLabelsStub = stub
}

func (fake *FakeActor) GetStackLabelsArgsForCall(i int) string {
	fake.getStackLabelsMutex.RLock()
	defer fake.getStackLabelsMutex.RUnlock()
	argsForCall := fake.getStackLabelsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetStackLabelsReturns(result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getStackLabelsMutex.Lock()
	defer fake.getStackLabelsMutex.Unlock()
	fake.GetStackLabelsStub = nil
	fake.getStackLabelsReturns = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetStackLabelsReturnsOnCall(i int, result1 map[string]types.NullString, result2 v7action.Warnings, result3 error) {
	fake.getStackLabelsMutex.Lock()
	defer fake.getStackLabelsMutex.Unlock()
	fake.GetStackLabelsStub = nil
	if fake.getStackLabelsReturnsOnCall == nil {
		fake.getStackLabelsReturnsOnCall = make(map[int]struct {
			result1 map[string]types.NullString
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getStackLabelsReturnsOnCall[i] = struct {
		result1 map[string]types.NullString
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetStacks(arg1 string) ([]resources.Stack, v7action.Warnings, error) {
	fake.getStacksMutex.Lock()
	ret, specificReturn := fake.getStacksReturnsOnCall[len(fake.getStacksArgsForCall)]
	fake.getStacksArgsForCall = append(fake.getStacksArgsForCall, struct {
		arg1 string
	}{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 *FakeActor) GetStacksCallCount() int {
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	return len(fake.getStacksArgsForCall)
}

func (fake *FakeActor) GetStacksCalls(stub func(string) ([]resources.Stack, v7action.Warnings, error)) {
	fake.getStacksMutex.Lock()
	defer fake.getStacksMutex.Unlock()
	fake.GetStacksStub = stub
}

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

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

func (fake *FakeActor) GetStacksReturnsOnCall(i int, result1 []resources.Stack, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.getStacksReturnsOnCall[i] = struct {
		result1 []resources.Stack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpace(arg1 string, arg2 string, arg3 sharedaction.LogCacheClient) (<-chan sharedaction.LogMessage, <-chan error, context.CancelFunc, v7action.Warnings, error) {
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getStreamingLogsForApplicationByNameAndSpaceReturnsOnCall[len(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall)]
	fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall = append(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 sharedaction.LogCacheClient
	}{arg1, arg2, arg3})
	fake.recordInvocation("GetStreamingLogsForApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Unlock()
	if fake.GetStreamingLogsForApplicationByNameAndSpaceStub != nil {
		return fake.GetStreamingLogsForApplicationByNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4, ret.result5
	}
	fakeReturns := fake.getStreamingLogsForApplicationByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4, fakeReturns.result5
}

func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceCallCount() int {
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RLock()
	defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RUnlock()
	return len(fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceCalls(stub func(string, string, sharedaction.LogCacheClient) (<-chan sharedaction.LogMessage, <-chan error, context.CancelFunc, v7action.Warnings, error)) {
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Lock()
	defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Unlock()
	fake.GetStreamingLogsForApplicationByNameAndSpaceStub = stub
}

func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceArgsForCall(i int) (string, string, sharedaction.LogCacheClient) {
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RLock()
	defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.getStreamingLogsForApplicationByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceReturns(result1 <-chan sharedaction.LogMessage, result2 <-chan error, result3 context.CancelFunc, result4 v7action.Warnings, result5 error) {
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Lock()
	defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Unlock()
	fake.GetStreamingLogsForApplicationByNameAndSpaceStub = nil
	fake.getStreamingLogsForApplicationByNameAndSpaceReturns = struct {
		result1 <-chan sharedaction.LogMessage
		result2 <-chan error
		result3 context.CancelFunc
		result4 v7action.Warnings
		result5 error
	}{result1, result2, result3, result4, result5}
}

func (fake *FakeActor) GetStreamingLogsForApplicationByNameAndSpaceReturnsOnCall(i int, result1 <-chan sharedaction.LogMessage, result2 <-chan error, result3 context.CancelFunc, result4 v7action.Warnings, result5 error) {
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Lock()
	defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Unlock()
	fake.GetStreamingLogsForApplicationByNameAndSpaceStub = nil
	if fake.getStreamingLogsForApplicationByNameAndSpaceReturnsOnCall == nil {
		fake.getStreamingLogsForApplicationByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 <-chan sharedaction.LogMessage
			result2 <-chan error
			result3 context.CancelFunc
			result4 v7action.Warnings
			result5 error
		})
	}
	fake.getStreamingLogsForApplicationByNameAndSpaceReturnsOnCall[i] = struct {
		result1 <-chan sharedaction.LogMessage
		result2 <-chan error
		result3 context.CancelFunc
		result4 v7action.Warnings
		result5 error
	}{result1, result2, result3, result4, result5}
}

func (fake *FakeActor) GetTaskBySequenceIDAndApplication(arg1 int, arg2 string) (resources.Task, v7action.Warnings, error) {
	fake.getTaskBySequenceIDAndApplicationMutex.Lock()
	ret, specificReturn := fake.getTaskBySequenceIDAndApplicationReturnsOnCall[len(fake.getTaskBySequenceIDAndApplicationArgsForCall)]
	fake.getTaskBySequenceIDAndApplicationArgsForCall = append(fake.getTaskBySequenceIDAndApplicationArgsForCall, struct {
		arg1 int
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetTaskBySequenceIDAndApplication", []interface{}{arg1, arg2})
	fake.getTaskBySequenceIDAndApplicationMutex.Unlock()
	if fake.GetTaskBySequenceIDAndApplicationStub != nil {
		return fake.GetTaskBySequenceIDAndApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getTaskBySequenceIDAndApplicationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetTaskBySequenceIDAndApplicationCallCount() int {
	fake.getTaskBySequenceIDAndApplicationMutex.RLock()
	defer fake.getTaskBySequenceIDAndApplicationMutex.RUnlock()
	return len(fake.getTaskBySequenceIDAndApplicationArgsForCall)
}

func (fake *FakeActor) GetTaskBySequenceIDAndApplicationCalls(stub func(int, string) (resources.Task, v7action.Warnings, error)) {
	fake.getTaskBySequenceIDAndApplicationMutex.Lock()
	defer fake.getTaskBySequenceIDAndApplicationMutex.Unlock()
	fake.GetTaskBySequenceIDAndApplicationStub = stub
}

func (fake *FakeActor) GetTaskBySequenceIDAndApplicationArgsForCall(i int) (int, string) {
	fake.getTaskBySequenceIDAndApplicationMutex.RLock()
	defer fake.getTaskBySequenceIDAndApplicationMutex.RUnlock()
	argsForCall := fake.getTaskBySequenceIDAndApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetTaskBySequenceIDAndApplicationReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.getTaskBySequenceIDAndApplicationMutex.Lock()
	defer fake.getTaskBySequenceIDAndApplicationMutex.Unlock()
	fake.GetTaskBySequenceIDAndApplicationStub = nil
	fake.getTaskBySequenceIDAndApplicationReturns = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetTaskBySequenceIDAndApplicationReturnsOnCall(i int, result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.getTaskBySequenceIDAndApplicationMutex.Lock()
	defer fake.getTaskBySequenceIDAndApplicationMutex.Unlock()
	fake.GetTaskBySequenceIDAndApplicationStub = nil
	if fake.getTaskBySequenceIDAndApplicationReturnsOnCall == nil {
		fake.getTaskBySequenceIDAndApplicationReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getTaskBySequenceIDAndApplicationReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetUAAAPIVersion() (string, error) {
	fake.getUAAAPIVersionMutex.Lock()
	ret, specificReturn := fake.getUAAAPIVersionReturnsOnCall[len(fake.getUAAAPIVersionArgsForCall)]
	fake.getUAAAPIVersionArgsForCall = append(fake.getUAAAPIVersionArgsForCall, struct {
	}{})
	fake.recordInvocation("GetUAAAPIVersion", []interface{}{})
	fake.getUAAAPIVersionMutex.Unlock()
	if fake.GetUAAAPIVersionStub != nil {
		return fake.GetUAAAPIVersionStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getUAAAPIVersionReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetUAAAPIVersionCallCount() int {
	fake.getUAAAPIVersionMutex.RLock()
	defer fake.getUAAAPIVersionMutex.RUnlock()
	return len(fake.getUAAAPIVersionArgsForCall)
}

func (fake *FakeActor) GetUAAAPIVersionCalls(stub func() (string, error)) {
	fake.getUAAAPIVersionMutex.Lock()
	defer fake.getUAAAPIVersionMutex.Unlock()
	fake.GetUAAAPIVersionStub = stub
}

func (fake *FakeActor) GetUAAAPIVersionReturns(result1 string, result2 error) {
	fake.getUAAAPIVersionMutex.Lock()
	defer fake.getUAAAPIVersionMutex.Unlock()
	fake.GetUAAAPIVersionStub = nil
	fake.getUAAAPIVersionReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetUAAAPIVersionReturnsOnCall(i int, result1 string, result2 error) {
	fake.getUAAAPIVersionMutex.Lock()
	defer fake.getUAAAPIVersionMutex.Unlock()
	fake.GetUAAAPIVersionStub = nil
	if fake.getUAAAPIVersionReturnsOnCall == nil {
		fake.getUAAAPIVersionReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.getUAAAPIVersionReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetUnstagedNewestPackageGUID(arg1 string) (string, v7action.Warnings, error) {
	fake.getUnstagedNewestPackageGUIDMutex.Lock()
	ret, specificReturn := fake.getUnstagedNewestPackageGUIDReturnsOnCall[len(fake.getUnstagedNewestPackageGUIDArgsForCall)]
	fake.getUnstagedNewestPackageGUIDArgsForCall = append(fake.getUnstagedNewestPackageGUIDArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("GetUnstagedNewestPackageGUID", []interface{}{arg1})
	fake.getUnstagedNewestPackageGUIDMutex.Unlock()
	if fake.GetUnstagedNewestPackageGUIDStub != nil {
		return fake.GetUnstagedNewestPackageGUIDStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.getUnstagedNewestPackageGUIDReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetUnstagedNewestPackageGUIDCallCount() int {
	fake.getUnstagedNewestPackageGUIDMutex.RLock()
	defer fake.getUnstagedNewestPackageGUIDMutex.RUnlock()
	return len(fake.getUnstagedNewestPackageGUIDArgsForCall)
}

func (fake *FakeActor) GetUnstagedNewestPackageGUIDCalls(stub func(string) (string, v7action.Warnings, error)) {
	fake.getUnstagedNewestPackageGUIDMutex.Lock()
	defer fake.getUnstagedNewestPackageGUIDMutex.Unlock()
	fake.GetUnstagedNewestPackageGUIDStub = stub
}

func (fake *FakeActor) GetUnstagedNewestPackageGUIDArgsForCall(i int) string {
	fake.getUnstagedNewestPackageGUIDMutex.RLock()
	defer fake.getUnstagedNewestPackageGUIDMutex.RUnlock()
	argsForCall := fake.getUnstagedNewestPackageGUIDArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetUnstagedNewestPackageGUIDReturns(result1 string, result2 v7action.Warnings, result3 error) {
	fake.getUnstagedNewestPackageGUIDMutex.Lock()
	defer fake.getUnstagedNewestPackageGUIDMutex.Unlock()
	fake.GetUnstagedNewestPackageGUIDStub = nil
	fake.getUnstagedNewestPackageGUIDReturns = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetUnstagedNewestPackageGUIDReturnsOnCall(i int, result1 string, result2 v7action.Warnings, result3 error) {
	fake.getUnstagedNewestPackageGUIDMutex.Lock()
	defer fake.getUnstagedNewestPackageGUIDMutex.Unlock()
	fake.GetUnstagedNewestPackageGUIDStub = nil
	if fake.getUnstagedNewestPackageGUIDReturnsOnCall == nil {
		fake.getUnstagedNewestPackageGUIDReturnsOnCall = make(map[int]struct {
			result1 string
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getUnstagedNewestPackageGUIDReturnsOnCall[i] = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetUser(arg1 string, arg2 string) (resources.User, error) {
	fake.getUserMutex.Lock()
	ret, specificReturn := fake.getUserReturnsOnCall[len(fake.getUserArgsForCall)]
	fake.getUserArgsForCall = append(fake.getUserArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("GetUser", []interface{}{arg1, arg2})
	fake.getUserMutex.Unlock()
	if fake.GetUserStub != nil {
		return fake.GetUserStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.getUserReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) GetUserCallCount() int {
	fake.getUserMutex.RLock()
	defer fake.getUserMutex.RUnlock()
	return len(fake.getUserArgsForCall)
}

func (fake *FakeActor) GetUserCalls(stub func(string, string) (resources.User, error)) {
	fake.getUserMutex.Lock()
	defer fake.getUserMutex.Unlock()
	fake.GetUserStub = stub
}

func (fake *FakeActor) GetUserArgsForCall(i int) (string, string) {
	fake.getUserMutex.RLock()
	defer fake.getUserMutex.RUnlock()
	argsForCall := fake.getUserArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) GetUserReturns(result1 resources.User, result2 error) {
	fake.getUserMutex.Lock()
	defer fake.getUserMutex.Unlock()
	fake.GetUserStub = nil
	fake.getUserReturns = struct {
		result1 resources.User
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) GetUserReturnsOnCall(i int, result1 resources.User, result2 error) {
	fake.getUserMutex.Lock()
	defer fake.getUserMutex.Unlock()
	fake.GetUserStub = nil
	if fake.getUserReturnsOnCall == nil {
		fake.getUserReturnsOnCall = make(map[int]struct {
			result1 resources.User
			result2 error
		})
	}
	fake.getUserReturnsOnCall[i] = struct {
		result1 resources.User
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) MakeCurlRequest(arg1 string, arg2 string, arg3 []string, arg4 string, arg5 bool) ([]byte, *http.Response, error) {
	var arg3Copy []string
	if arg3 != nil {
		arg3Copy = make([]string, len(arg3))
		copy(arg3Copy, arg3)
	}
	fake.makeCurlRequestMutex.Lock()
	ret, specificReturn := fake.makeCurlRequestReturnsOnCall[len(fake.makeCurlRequestArgsForCall)]
	fake.makeCurlRequestArgsForCall = append(fake.makeCurlRequestArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 []string
		arg4 string
		arg5 bool
	}{arg1, arg2, arg3Copy, arg4, arg5})
	fake.recordInvocation("MakeCurlRequest", []interface{}{arg1, arg2, arg3Copy, arg4, arg5})
	fake.makeCurlRequestMutex.Unlock()
	if fake.MakeCurlRequestStub != nil {
		return fake.MakeCurlRequestStub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.makeCurlRequestReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) MakeCurlRequestCallCount() int {
	fake.makeCurlRequestMutex.RLock()
	defer fake.makeCurlRequestMutex.RUnlock()
	return len(fake.makeCurlRequestArgsForCall)
}

func (fake *FakeActor) MakeCurlRequestCalls(stub func(string, string, []string, string, bool) ([]byte, *http.Response, error)) {
	fake.makeCurlRequestMutex.Lock()
	defer fake.makeCurlRequestMutex.Unlock()
	fake.MakeCurlRequestStub = stub
}

func (fake *FakeActor) MakeCurlRequestArgsForCall(i int) (string, string, []string, string, bool) {
	fake.makeCurlRequestMutex.RLock()
	defer fake.makeCurlRequestMutex.RUnlock()
	argsForCall := fake.makeCurlRequestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeActor) MakeCurlRequestReturns(result1 []byte, result2 *http.Response, result3 error) {
	fake.makeCurlRequestMutex.Lock()
	defer fake.makeCurlRequestMutex.Unlock()
	fake.MakeCurlRequestStub = nil
	fake.makeCurlRequestReturns = struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) MakeCurlRequestReturnsOnCall(i int, result1 []byte, result2 *http.Response, result3 error) {
	fake.makeCurlRequestMutex.Lock()
	defer fake.makeCurlRequestMutex.Unlock()
	fake.MakeCurlRequestStub = nil
	if fake.makeCurlRequestReturnsOnCall == nil {
		fake.makeCurlRequestReturnsOnCall = make(map[int]struct {
			result1 []byte
			result2 *http.Response
			result3 error
		})
	}
	fake.makeCurlRequestReturnsOnCall[i] = struct {
		result1 []byte
		result2 *http.Response
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) MapRoute(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.mapRouteMutex.Lock()
	ret, specificReturn := fake.mapRouteReturnsOnCall[len(fake.mapRouteArgsForCall)]
	fake.mapRouteArgsForCall = append(fake.mapRouteArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("MapRoute", []interface{}{arg1, arg2, arg3})
	fake.mapRouteMutex.Unlock()
	if fake.MapRouteStub != nil {
		return fake.MapRouteStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.mapRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) MapRouteCallCount() int {
	fake.mapRouteMutex.RLock()
	defer fake.mapRouteMutex.RUnlock()
	return len(fake.mapRouteArgsForCall)
}

func (fake *FakeActor) MapRouteCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.mapRouteMutex.Lock()
	defer fake.mapRouteMutex.Unlock()
	fake.MapRouteStub = stub
}

func (fake *FakeActor) MapRouteArgsForCall(i int) (string, string, string) {
	fake.mapRouteMutex.RLock()
	defer fake.mapRouteMutex.RUnlock()
	argsForCall := fake.mapRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) MapRouteReturns(result1 v7action.Warnings, result2 error) {
	fake.mapRouteMutex.Lock()
	defer fake.mapRouteMutex.Unlock()
	fake.MapRouteStub = nil
	fake.mapRouteReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) MapRouteReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.mapRouteMutex.Lock()
	defer fake.mapRouteMutex.Unlock()
	fake.MapRouteStub = nil
	if fake.mapRouteReturnsOnCall == nil {
		fake.mapRouteReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.mapRouteReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) Marketplace(arg1 v7action.MarketplaceFilter) ([]v7action.ServiceOfferingWithPlans, v7action.Warnings, error) {
	fake.marketplaceMutex.Lock()
	ret, specificReturn := fake.marketplaceReturnsOnCall[len(fake.marketplaceArgsForCall)]
	fake.marketplaceArgsForCall = append(fake.marketplaceArgsForCall, struct {
		arg1 v7action.MarketplaceFilter
	}{arg1})
	fake.recordInvocation("Marketplace", []interface{}{arg1})
	fake.marketplaceMutex.Unlock()
	if fake.MarketplaceStub != nil {
		return fake.MarketplaceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.marketplaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) MarketplaceCallCount() int {
	fake.marketplaceMutex.RLock()
	defer fake.marketplaceMutex.RUnlock()
	return len(fake.marketplaceArgsForCall)
}

func (fake *FakeActor) MarketplaceCalls(stub func(v7action.MarketplaceFilter) ([]v7action.ServiceOfferingWithPlans, v7action.Warnings, error)) {
	fake.marketplaceMutex.Lock()
	defer fake.marketplaceMutex.Unlock()
	fake.MarketplaceStub = stub
}

func (fake *FakeActor) MarketplaceArgsForCall(i int) v7action.MarketplaceFilter {
	fake.marketplaceMutex.RLock()
	defer fake.marketplaceMutex.RUnlock()
	argsForCall := fake.marketplaceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) MarketplaceReturns(result1 []v7action.ServiceOfferingWithPlans, result2 v7action.Warnings, result3 error) {
	fake.marketplaceMutex.Lock()
	defer fake.marketplaceMutex.Unlock()
	fake.MarketplaceStub = nil
	fake.marketplaceReturns = struct {
		result1 []v7action.ServiceOfferingWithPlans
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) MarketplaceReturnsOnCall(i int, result1 []v7action.ServiceOfferingWithPlans, result2 v7action.Warnings, result3 error) {
	fake.marketplaceMutex.Lock()
	defer fake.marketplaceMutex.Unlock()
	fake.MarketplaceStub = nil
	if fake.marketplaceReturnsOnCall == nil {
		fake.marketplaceReturnsOnCall = make(map[int]struct {
			result1 []v7action.ServiceOfferingWithPlans
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.marketplaceReturnsOnCall[i] = struct {
		result1 []v7action.ServiceOfferingWithPlans
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) MoveRoute(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.moveRouteMutex.Lock()
	ret, specificReturn := fake.moveRouteReturnsOnCall[len(fake.moveRouteArgsForCall)]
	fake.moveRouteArgsForCall = append(fake.moveRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("MoveRoute", []interface{}{arg1, arg2})
	fake.moveRouteMutex.Unlock()
	if fake.MoveRouteStub != nil {
		return fake.MoveRouteStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.moveRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) MoveRouteCallCount() int {
	fake.moveRouteMutex.RLock()
	defer fake.moveRouteMutex.RUnlock()
	return len(fake.moveRouteArgsForCall)
}

func (fake *FakeActor) MoveRouteCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.moveRouteMutex.Lock()
	defer fake.moveRouteMutex.Unlock()
	fake.MoveRouteStub = stub
}

func (fake *FakeActor) MoveRouteArgsForCall(i int) (string, string) {
	fake.moveRouteMutex.RLock()
	defer fake.moveRouteMutex.RUnlock()
	argsForCall := fake.moveRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) MoveRouteReturns(result1 v7action.Warnings, result2 error) {
	fake.moveRouteMutex.Lock()
	defer fake.moveRouteMutex.Unlock()
	fake.MoveRouteStub = nil
	fake.moveRouteReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) MoveRouteReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.moveRouteMutex.Lock()
	defer fake.moveRouteMutex.Unlock()
	fake.MoveRouteStub = nil
	if fake.moveRouteReturnsOnCall == nil {
		fake.moveRouteReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.moveRouteReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ParseAccessToken(arg1 string) (jwt.JWT, error) {
	fake.parseAccessTokenMutex.Lock()
	ret, specificReturn := fake.parseAccessTokenReturnsOnCall[len(fake.parseAccessTokenArgsForCall)]
	fake.parseAccessTokenArgsForCall = append(fake.parseAccessTokenArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("ParseAccessToken", []interface{}{arg1})
	fake.parseAccessTokenMutex.Unlock()
	if fake.ParseAccessTokenStub != nil {
		return fake.ParseAccessTokenStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.parseAccessTokenReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ParseAccessTokenCallCount() int {
	fake.parseAccessTokenMutex.RLock()
	defer fake.parseAccessTokenMutex.RUnlock()
	return len(fake.parseAccessTokenArgsForCall)
}

func (fake *FakeActor) ParseAccessTokenCalls(stub func(string) (jwt.JWT, error)) {
	fake.parseAccessTokenMutex.Lock()
	defer fake.parseAccessTokenMutex.Unlock()
	fake.ParseAccessTokenStub = stub
}

func (fake *FakeActor) ParseAccessTokenArgsForCall(i int) string {
	fake.parseAccessTokenMutex.RLock()
	defer fake.parseAccessTokenMutex.RUnlock()
	argsForCall := fake.parseAccessTokenArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) ParseAccessTokenReturns(result1 jwt.JWT, result2 error) {
	fake.parseAccessTokenMutex.Lock()
	defer fake.parseAccessTokenMutex.Unlock()
	fake.ParseAccessTokenStub = nil
	fake.parseAccessTokenReturns = struct {
		result1 jwt.JWT
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ParseAccessTokenReturnsOnCall(i int, result1 jwt.JWT, result2 error) {
	fake.parseAccessTokenMutex.Lock()
	defer fake.parseAccessTokenMutex.Unlock()
	fake.ParseAccessTokenStub = nil
	if fake.parseAccessTokenReturnsOnCall == nil {
		fake.parseAccessTokenReturnsOnCall = make(map[int]struct {
			result1 jwt.JWT
			result2 error
		})
	}
	fake.parseAccessTokenReturnsOnCall[i] = struct {
		result1 jwt.JWT
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollBuild(arg1 string, arg2 string) (resources.Droplet, v7action.Warnings, error) {
	fake.pollBuildMutex.Lock()
	ret, specificReturn := fake.pollBuildReturnsOnCall[len(fake.pollBuildArgsForCall)]
	fake.pollBuildArgsForCall = append(fake.pollBuildArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("PollBuild", []interface{}{arg1, arg2})
	fake.pollBuildMutex.Unlock()
	if fake.PollBuildStub != nil {
		return fake.PollBuildStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.pollBuildReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) PollBuildCallCount() int {
	fake.pollBuildMutex.RLock()
	defer fake.pollBuildMutex.RUnlock()
	return len(fake.pollBuildArgsForCall)
}

func (fake *FakeActor) PollBuildCalls(stub func(string, string) (resources.Droplet, v7action.Warnings, error)) {
	fake.pollBuildMutex.Lock()
	defer fake.pollBuildMutex.Unlock()
	fake.PollBuildStub = stub
}

func (fake *FakeActor) PollBuildArgsForCall(i int) (string, string) {
	fake.pollBuildMutex.RLock()
	defer fake.pollBuildMutex.RUnlock()
	argsForCall := fake.pollBuildArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) PollBuildReturns(result1 resources.Droplet, result2 v7action.Warnings, result3 error) {
	fake.pollBuildMutex.Lock()
	defer fake.pollBuildMutex.Unlock()
	fake.PollBuildStub = nil
	fake.pollBuildReturns = struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) PollBuildReturnsOnCall(i int, result1 resources.Droplet, result2 v7action.Warnings, result3 error) {
	fake.pollBuildMutex.Lock()
	defer fake.pollBuildMutex.Unlock()
	fake.PollBuildStub = nil
	if fake.pollBuildReturnsOnCall == nil {
		fake.pollBuildReturnsOnCall = make(map[int]struct {
			result1 resources.Droplet
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.pollBuildReturnsOnCall[i] = struct {
		result1 resources.Droplet
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) PollPackage(arg1 resources.Package) (resources.Package, v7action.Warnings, error) {
	fake.pollPackageMutex.Lock()
	ret, specificReturn := fake.pollPackageReturnsOnCall[len(fake.pollPackageArgsForCall)]
	fake.pollPackageArgsForCall = append(fake.pollPackageArgsForCall, struct {
		arg1 resources.Package
	}{arg1})
	fake.recordInvocation("PollPackage", []interface{}{arg1})
	fake.pollPackageMutex.Unlock()
	if fake.PollPackageStub != nil {
		return fake.PollPackageStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.pollPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) PollPackageCallCount() int {
	fake.pollPackageMutex.RLock()
	defer fake.pollPackageMutex.RUnlock()
	return len(fake.pollPackageArgsForCall)
}

func (fake *FakeActor) PollPackageCalls(stub func(resources.Package) (resources.Package, v7action.Warnings, error)) {
	fake.pollPackageMutex.Lock()
	defer fake.pollPackageMutex.Unlock()
	fake.PollPackageStub = stub
}

func (fake *FakeActor) PollPackageArgsForCall(i int) resources.Package {
	fake.pollPackageMutex.RLock()
	defer fake.pollPackageMutex.RUnlock()
	argsForCall := fake.pollPackageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) PollPackageReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.pollPackageMutex.Lock()
	defer fake.pollPackageMutex.Unlock()
	fake.PollPackageStub = nil
	fake.pollPackageReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) PollPackageReturnsOnCall(i int, result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.pollPackageMutex.Lock()
	defer fake.pollPackageMutex.Unlock()
	fake.PollPackageStub = nil
	if fake.pollPackageReturnsOnCall == nil {
		fake.pollPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Package
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.pollPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) PollStart(arg1 resources.Application, arg2 bool, arg3 func(string)) (v7action.Warnings, error) {
	fake.pollStartMutex.Lock()
	ret, specificReturn := fake.pollStartReturnsOnCall[len(fake.pollStartArgsForCall)]
	fake.pollStartArgsForCall = append(fake.pollStartArgsForCall, struct {
		arg1 resources.Application
		arg2 bool
		arg3 func(string)
	}{arg1, arg2, arg3})
	fake.recordInvocation("PollStart", []interface{}{arg1, arg2, arg3})
	fake.pollStartMutex.Unlock()
	if fake.PollStartStub != nil {
		return fake.PollStartStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.pollStartReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PollStartCallCount() int {
	fake.pollStartMutex.RLock()
	defer fake.pollStartMutex.RUnlock()
	return len(fake.pollStartArgsForCall)
}

func (fake *FakeActor) PollStartCalls(stub func(resources.Application, bool, func(string)) (v7action.Warnings, error)) {
	fake.pollStartMutex.Lock()
	defer fake.pollStartMutex.Unlock()
	fake.PollStartStub = stub
}

func (fake *FakeActor) PollStartArgsForCall(i int) (resources.Application, bool, func(string)) {
	fake.pollStartMutex.RLock()
	defer fake.pollStartMutex.RUnlock()
	argsForCall := fake.pollStartArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) PollStartReturns(result1 v7action.Warnings, result2 error) {
	fake.pollStartMutex.Lock()
	defer fake.pollStartMutex.Unlock()
	fake.PollStartStub = nil
	fake.pollStartReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollStartReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.pollStartMutex.Lock()
	defer fake.pollStartMutex.Unlock()
	fake.PollStartStub = nil
	if fake.pollStartReturnsOnCall == nil {
		fake.pollStartReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.pollStartReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollStartForRolling(arg1 resources.Application, arg2 string, arg3 bool, arg4 func(string)) (v7action.Warnings, error) {
	fake.pollStartForRollingMutex.Lock()
	ret, specificReturn := fake.pollStartForRollingReturnsOnCall[len(fake.pollStartForRollingArgsForCall)]
	fake.pollStartForRollingArgsForCall = append(fake.pollStartForRollingArgsForCall, struct {
		arg1 resources.Application
		arg2 string
		arg3 bool
		arg4 func(string)
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("PollStartForRolling", []interface{}{arg1, arg2, arg3, arg4})
	fake.pollStartForRollingMutex.Unlock()
	if fake.PollStartForRollingStub != nil {
		return fake.PollStartForRollingStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.pollStartForRollingReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PollStartForRollingCallCount() int {
	fake.pollStartForRollingMutex.RLock()
	defer fake.pollStartForRollingMutex.RUnlock()
	return len(fake.pollStartForRollingArgsForCall)
}

func (fake *FakeActor) PollStartForRollingCalls(stub func(resources.Application, string, bool, func(string)) (v7action.Warnings, error)) {
	fake.pollStartForRollingMutex.Lock()
	defer fake.pollStartForRollingMutex.Unlock()
	fake.PollStartForRollingStub = stub
}

func (fake *FakeActor) PollStartForRollingArgsForCall(i int) (resources.Application, string, bool, func(string)) {
	fake.pollStartForRollingMutex.RLock()
	defer fake.pollStartForRollingMutex.RUnlock()
	argsForCall := fake.pollStartForRollingArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) PollStartForRollingReturns(result1 v7action.Warnings, result2 error) {
	fake.pollStartForRollingMutex.Lock()
	defer fake.pollStartForRollingMutex.Unlock()
	fake.PollStartForRollingStub = nil
	fake.pollStartForRollingReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollStartForRollingReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.pollStartForRollingMutex.Lock()
	defer fake.pollStartForRollingMutex.Unlock()
	fake.PollStartForRollingStub = nil
	if fake.pollStartForRollingReturnsOnCall == nil {
		fake.pollStartForRollingReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.pollStartForRollingReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollTask(arg1 resources.Task) (resources.Task, v7action.Warnings, error) {
	fake.pollTaskMutex.Lock()
	ret, specificReturn := fake.pollTaskReturnsOnCall[len(fake.pollTaskArgsForCall)]
	fake.pollTaskArgsForCall = append(fake.pollTaskArgsForCall, struct {
		arg1 resources.Task
	}{arg1})
	fake.recordInvocation("PollTask", []interface{}{arg1})
	fake.pollTaskMutex.Unlock()
	if fake.PollTaskStub != nil {
		return fake.PollTaskStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.pollTaskReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) PollTaskCallCount() int {
	fake.pollTaskMutex.RLock()
	defer fake.pollTaskMutex.RUnlock()
	return len(fake.pollTaskArgsForCall)
}

func (fake *FakeActor) PollTaskCalls(stub func(resources.Task) (resources.Task, v7action.Warnings, error)) {
	fake.pollTaskMutex.Lock()
	defer fake.pollTaskMutex.Unlock()
	fake.PollTaskStub = stub
}

func (fake *FakeActor) PollTaskArgsForCall(i int) resources.Task {
	fake.pollTaskMutex.RLock()
	defer fake.pollTaskMutex.RUnlock()
	argsForCall := fake.pollTaskArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) PollTaskReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.pollTaskMutex.Lock()
	defer fake.pollTaskMutex.Unlock()
	fake.PollTaskStub = nil
	fake.pollTaskReturns = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) PollTaskReturnsOnCall(i int, result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.pollTaskMutex.Lock()
	defer fake.pollTaskMutex.Unlock()
	fake.PollTaskStub = nil
	if fake.pollTaskReturnsOnCall == nil {
		fake.pollTaskReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.pollTaskReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) PollUploadBuildpackJob(arg1 ccv3.JobURL) (v7action.Warnings, error) {
	fake.pollUploadBuildpackJobMutex.Lock()
	ret, specificReturn := fake.pollUploadBuildpackJobReturnsOnCall[len(fake.pollUploadBuildpackJobArgsForCall)]
	fake.pollUploadBuildpackJobArgsForCall = append(fake.pollUploadBuildpackJobArgsForCall, struct {
		arg1 ccv3.JobURL
	}{arg1})
	fake.recordInvocation("PollUploadBuildpackJob", []interface{}{arg1})
	fake.pollUploadBuildpackJobMutex.Unlock()
	if fake.PollUploadBuildpackJobStub != nil {
		return fake.PollUploadBuildpackJobStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.pollUploadBuildpackJobReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PollUploadBuildpackJobCallCount() int {
	fake.pollUploadBuildpackJobMutex.RLock()
	defer fake.pollUploadBuildpackJobMutex.RUnlock()
	return len(fake.pollUploadBuildpackJobArgsForCall)
}

func (fake *FakeActor) PollUploadBuildpackJobCalls(stub func(ccv3.JobURL) (v7action.Warnings, error)) {
	fake.pollUploadBuildpackJobMutex.Lock()
	defer fake.pollUploadBuildpackJobMutex.Unlock()
	fake.PollUploadBuildpackJobStub = stub
}

func (fake *FakeActor) PollUploadBuildpackJobArgsForCall(i int) ccv3.JobURL {
	fake.pollUploadBuildpackJobMutex.RLock()
	defer fake.pollUploadBuildpackJobMutex.RUnlock()
	argsForCall := fake.pollUploadBuildpackJobArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) PollUploadBuildpackJobReturns(result1 v7action.Warnings, result2 error) {
	fake.pollUploadBuildpackJobMutex.Lock()
	defer fake.pollUploadBuildpackJobMutex.Unlock()
	fake.PollUploadBuildpackJobStub = nil
	fake.pollUploadBuildpackJobReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollUploadBuildpackJobReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.pollUploadBuildpackJobMutex.Lock()
	defer fake.pollUploadBuildpackJobMutex.Unlock()
	fake.PollUploadBuildpackJobStub = nil
	if fake.pollUploadBuildpackJobReturnsOnCall == nil {
		fake.pollUploadBuildpackJobReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.pollUploadBuildpackJobReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PrepareBuildpackBits(arg1 string, arg2 string, arg3 v7action.Downloader) (string, error) {
	fake.prepareBuildpackBitsMutex.Lock()
	ret, specificReturn := fake.prepareBuildpackBitsReturnsOnCall[len(fake.prepareBuildpackBitsArgsForCall)]
	fake.prepareBuildpackBitsArgsForCall = append(fake.prepareBuildpackBitsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 v7action.Downloader
	}{arg1, arg2, arg3})
	fake.recordInvocation("PrepareBuildpackBits", []interface{}{arg1, arg2, arg3})
	fake.prepareBuildpackBitsMutex.Unlock()
	if fake.PrepareBuildpackBitsStub != nil {
		return fake.PrepareBuildpackBitsStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.prepareBuildpackBitsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PrepareBuildpackBitsCallCount() int {
	fake.prepareBuildpackBitsMutex.RLock()
	defer fake.prepareBuildpackBitsMutex.RUnlock()
	return len(fake.prepareBuildpackBitsArgsForCall)
}

func (fake *FakeActor) PrepareBuildpackBitsCalls(stub func(string, string, v7action.Downloader) (string, error)) {
	fake.prepareBuildpackBitsMutex.Lock()
	defer fake.prepareBuildpackBitsMutex.Unlock()
	fake.PrepareBuildpackBitsStub = stub
}

func (fake *FakeActor) PrepareBuildpackBitsArgsForCall(i int) (string, string, v7action.Downloader) {
	fake.prepareBuildpackBitsMutex.RLock()
	defer fake.prepareBuildpackBitsMutex.RUnlock()
	argsForCall := fake.prepareBuildpackBitsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) PrepareBuildpackBitsReturns(result1 string, result2 error) {
	fake.prepareBuildpackBitsMutex.Lock()
	defer fake.prepareBuildpackBitsMutex.Unlock()
	fake.PrepareBuildpackBitsStub = nil
	fake.prepareBuildpackBitsReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PrepareBuildpackBitsReturnsOnCall(i int, result1 string, result2 error) {
	fake.prepareBuildpackBitsMutex.Lock()
	defer fake.prepareBuildpackBitsMutex.Unlock()
	fake.PrepareBuildpackBitsStub = nil
	if fake.prepareBuildpackBitsReturnsOnCall == nil {
		fake.prepareBuildpackBitsReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.prepareBuildpackBitsReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PurgeServiceInstance(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.purgeServiceInstanceMutex.Lock()
	ret, specificReturn := fake.purgeServiceInstanceReturnsOnCall[len(fake.purgeServiceInstanceArgsForCall)]
	fake.purgeServiceInstanceArgsForCall = append(fake.purgeServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("PurgeServiceInstance", []interface{}{arg1, arg2})
	fake.purgeServiceInstanceMutex.Unlock()
	if fake.PurgeServiceInstanceStub != nil {
		return fake.PurgeServiceInstanceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.purgeServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PurgeServiceInstanceCallCount() int {
	fake.purgeServiceInstanceMutex.RLock()
	defer fake.purgeServiceInstanceMutex.RUnlock()
	return len(fake.purgeServiceInstanceArgsForCall)
}

func (fake *FakeActor) PurgeServiceInstanceCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.purgeServiceInstanceMutex.Lock()
	defer fake.purgeServiceInstanceMutex.Unlock()
	fake.PurgeServiceInstanceStub = stub
}

func (fake *FakeActor) PurgeServiceInstanceArgsForCall(i int) (string, string) {
	fake.purgeServiceInstanceMutex.RLock()
	defer fake.purgeServiceInstanceMutex.RUnlock()
	argsForCall := fake.purgeServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) PurgeServiceInstanceReturns(result1 v7action.Warnings, result2 error) {
	fake.purgeServiceInstanceMutex.Lock()
	defer fake.purgeServiceInstanceMutex.Unlock()
	fake.PurgeServiceInstanceStub = nil
	fake.purgeServiceInstanceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PurgeServiceInstanceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.purgeServiceInstanceMutex.Lock()
	defer fake.purgeServiceInstanceMutex.Unlock()
	fake.PurgeServiceInstanceStub = nil
	if fake.purgeServiceInstanceReturnsOnCall == nil {
		fake.purgeServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.purgeServiceInstanceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PurgeServiceOfferingByNameAndBroker(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.purgeServiceOfferingByNameAndBrokerMutex.Lock()
	ret, specificReturn := fake.purgeServiceOfferingByNameAndBrokerReturnsOnCall[len(fake.purgeServiceOfferingByNameAndBrokerArgsForCall)]
	fake.purgeServiceOfferingByNameAndBrokerArgsForCall = append(fake.purgeServiceOfferingByNameAndBrokerArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("PurgeServiceOfferingByNameAndBroker", []interface{}{arg1, arg2})
	fake.purgeServiceOfferingByNameAndBrokerMutex.Unlock()
	if fake.PurgeServiceOfferingByNameAndBrokerStub != nil {
		return fake.PurgeServiceOfferingByNameAndBrokerStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.purgeServiceOfferingByNameAndBrokerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerCallCount() int {
	fake.purgeServiceOfferingByNameAndBrokerMutex.RLock()
	defer fake.purgeServiceOfferingByNameAndBrokerMutex.RUnlock()
	return len(fake.purgeServiceOfferingByNameAndBrokerArgsForCall)
}

func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.purgeServiceOfferingByNameAndBrokerMutex.Lock()
	defer fake.purgeServiceOfferingByNameAndBrokerMutex.Unlock()
	fake.PurgeServiceOfferingByNameAndBrokerStub = stub
}

func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerArgsForCall(i int) (string, string) {
	fake.purgeServiceOfferingByNameAndBrokerMutex.RLock()
	defer fake.purgeServiceOfferingByNameAndBrokerMutex.RUnlock()
	argsForCall := fake.purgeServiceOfferingByNameAndBrokerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerReturns(result1 v7action.Warnings, result2 error) {
	fake.purgeServiceOfferingByNameAndBrokerMutex.Lock()
	defer fake.purgeServiceOfferingByNameAndBrokerMutex.Unlock()
	fake.PurgeServiceOfferingByNameAndBrokerStub = nil
	fake.purgeServiceOfferingByNameAndBrokerReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PurgeServiceOfferingByNameAndBrokerReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.purgeServiceOfferingByNameAndBrokerMutex.Lock()
	defer fake.purgeServiceOfferingByNameAndBrokerMutex.Unlock()
	fake.PurgeServiceOfferingByNameAndBrokerStub = nil
	if fake.purgeServiceOfferingByNameAndBrokerReturnsOnCall == nil {
		fake.purgeServiceOfferingByNameAndBrokerReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.purgeServiceOfferingByNameAndBrokerReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RefreshAccessToken() (string, error) {
	fake.refreshAccessTokenMutex.Lock()
	ret, specificReturn := fake.refreshAccessTokenReturnsOnCall[len(fake.refreshAccessTokenArgsForCall)]
	fake.refreshAccessTokenArgsForCall = append(fake.refreshAccessTokenArgsForCall, struct {
	}{})
	fake.recordInvocation("RefreshAccessToken", []interface{}{})
	fake.refreshAccessTokenMutex.Unlock()
	if fake.RefreshAccessTokenStub != nil {
		return fake.RefreshAccessTokenStub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.refreshAccessTokenReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) RefreshAccessTokenCallCount() int {
	fake.refreshAccessTokenMutex.RLock()
	defer fake.refreshAccessTokenMutex.RUnlock()
	return len(fake.refreshAccessTokenArgsForCall)
}

func (fake *FakeActor) RefreshAccessTokenCalls(stub func() (string, error)) {
	fake.refreshAccessTokenMutex.Lock()
	defer fake.refreshAccessTokenMutex.Unlock()
	fake.RefreshAccessTokenStub = stub
}

func (fake *FakeActor) RefreshAccessTokenReturns(result1 string, result2 error) {
	fake.refreshAccessTokenMutex.Lock()
	defer fake.refreshAccessTokenMutex.Unlock()
	fake.RefreshAccessTokenStub = nil
	fake.refreshAccessTokenReturns = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RefreshAccessTokenReturnsOnCall(i int, result1 string, result2 error) {
	fake.refreshAccessTokenMutex.Lock()
	defer fake.refreshAccessTokenMutex.Unlock()
	fake.RefreshAccessTokenStub = nil
	if fake.refreshAccessTokenReturnsOnCall == nil {
		fake.refreshAccessTokenReturnsOnCall = make(map[int]struct {
			result1 string
			result2 error
		})
	}
	fake.refreshAccessTokenReturnsOnCall[i] = struct {
		result1 string
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RenameApplicationByNameAndSpaceGUID(arg1 string, arg2 string, arg3 string) (resources.Application, v7action.Warnings, error) {
	fake.renameApplicationByNameAndSpaceGUIDMutex.Lock()
	ret, specificReturn := fake.renameApplicationByNameAndSpaceGUIDReturnsOnCall[len(fake.renameApplicationByNameAndSpaceGUIDArgsForCall)]
	fake.renameApplicationByNameAndSpaceGUIDArgsForCall = append(fake.renameApplicationByNameAndSpaceGUIDArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("RenameApplicationByNameAndSpaceGUID", []interface{}{arg1, arg2, arg3})
	fake.renameApplicationByNameAndSpaceGUIDMutex.Unlock()
	if fake.RenameApplicationByNameAndSpaceGUIDStub != nil {
		return fake.RenameApplicationByNameAndSpaceGUIDStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.renameApplicationByNameAndSpaceGUIDReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDCallCount() int {
	fake.renameApplicationByNameAndSpaceGUIDMutex.RLock()
	defer fake.renameApplicationByNameAndSpaceGUIDMutex.RUnlock()
	return len(fake.renameApplicationByNameAndSpaceGUIDArgsForCall)
}

func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDCalls(stub func(string, string, string) (resources.Application, v7action.Warnings, error)) {
	fake.renameApplicationByNameAndSpaceGUIDMutex.Lock()
	defer fake.renameApplicationByNameAndSpaceGUIDMutex.Unlock()
	fake.RenameApplicationByNameAndSpaceGUIDStub = stub
}

func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDArgsForCall(i int) (string, string, string) {
	fake.renameApplicationByNameAndSpaceGUIDMutex.RLock()
	defer fake.renameApplicationByNameAndSpaceGUIDMutex.RUnlock()
	argsForCall := fake.renameApplicationByNameAndSpaceGUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.renameApplicationByNameAndSpaceGUIDMutex.Lock()
	defer fake.renameApplicationByNameAndSpaceGUIDMutex.Unlock()
	fake.RenameApplicationByNameAndSpaceGUIDStub = nil
	fake.renameApplicationByNameAndSpaceGUIDReturns = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) RenameApplicationByNameAndSpaceGUIDReturnsOnCall(i int, result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.renameApplicationByNameAndSpaceGUIDMutex.Lock()
	defer fake.renameApplicationByNameAndSpaceGUIDMutex.Unlock()
	fake.RenameApplicationByNameAndSpaceGUIDStub = nil
	if fake.renameApplicationByNameAndSpaceGUIDReturnsOnCall == nil {
		fake.renameApplicationByNameAndSpaceGUIDReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.renameApplicationByNameAndSpaceGUIDReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) RenameOrganization(arg1 string, arg2 string) (resources.Organization, v7action.Warnings, error) {
	fake.renameOrganizationMutex.Lock()
	ret, specificReturn := fake.renameOrganizationReturnsOnCall[len(fake.renameOrganizationArgsForCall)]
	fake.renameOrganizationArgsForCall = append(fake.renameOrganizationArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("RenameOrganization", []interface{}{arg1, arg2})
	fake.renameOrganizationMutex.Unlock()
	if fake.RenameOrganizationStub != nil {
		return fake.RenameOrganizationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.renameOrganizationReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) RenameOrganizationCallCount() int {
	fake.renameOrganizationMutex.RLock()
	defer fake.renameOrganizationMutex.RUnlock()
	return len(fake.renameOrganizationArgsForCall)
}

func (fake *FakeActor) RenameOrganizationCalls(stub func(string, string) (resources.Organization, v7action.Warnings, error)) {
	fake.renameOrganizationMutex.Lock()
	defer fake.renameOrganizationMutex.Unlock()
	fake.RenameOrganizationStub = stub
}

func (fake *FakeActor) RenameOrganizationArgsForCall(i int) (string, string) {
	fake.renameOrganizationMutex.RLock()
	defer fake.renameOrganizationMutex.RUnlock()
	argsForCall := fake.renameOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) RenameOrganizationReturns(result1 resources.Organization, result2 v7action.Warnings, result3 error) {
	fake.renameOrganizationMutex.Lock()
	defer fake.renameOrganizationMutex.Unlock()
	fake.RenameOrganizationStub = nil
	fake.renameOrganizationReturns = struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) RenameOrganizationReturnsOnCall(i int, result1 resources.Organization, result2 v7action.Warnings, result3 error) {
	fake.renameOrganizationMutex.Lock()
	defer fake.renameOrganizationMutex.Unlock()
	fake.RenameOrganizationStub = nil
	if fake.renameOrganizationReturnsOnCall == nil {
		fake.renameOrganizationReturnsOnCall = make(map[int]struct {
			result1 resources.Organization
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.renameOrganizationReturnsOnCall[i] = struct {
		result1 resources.Organization
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) RenameServiceInstance(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.renameServiceInstanceMutex.Lock()
	ret, specificReturn := fake.renameServiceInstanceReturnsOnCall[len(fake.renameServiceInstanceArgsForCall)]
	fake.renameServiceInstanceArgsForCall = append(fake.renameServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("RenameServiceInstance", []interface{}{arg1, arg2, arg3})
	fake.renameServiceInstanceMutex.Unlock()
	if fake.RenameServiceInstanceStub != nil {
		return fake.RenameServiceInstanceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.renameServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) RenameServiceInstanceCallCount() int {
	fake.renameServiceInstanceMutex.RLock()
	defer fake.renameServiceInstanceMutex.RUnlock()
	return len(fake.renameServiceInstanceArgsForCall)
}

func (fake *FakeActor) RenameServiceInstanceCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.renameServiceInstanceMutex.Lock()
	defer fake.renameServiceInstanceMutex.Unlock()
	fake.RenameServiceInstanceStub = stub
}

func (fake *FakeActor) RenameServiceInstanceArgsForCall(i int) (string, string, string) {
	fake.renameServiceInstanceMutex.RLock()
	defer fake.renameServiceInstanceMutex.RUnlock()
	argsForCall := fake.renameServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) RenameServiceInstanceReturns(result1 v7action.Warnings, result2 error) {
	fake.renameServiceInstanceMutex.Lock()
	defer fake.renameServiceInstanceMutex.Unlock()
	fake.RenameServiceInstanceStub = nil
	fake.renameServiceInstanceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RenameServiceInstanceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.renameServiceInstanceMutex.Lock()
	defer fake.renameServiceInstanceMutex.Unlock()
	fake.RenameServiceInstanceStub = nil
	if fake.renameServiceInstanceReturnsOnCall == nil {
		fake.renameServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.renameServiceInstanceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUID(arg1 string, arg2 string, arg3 string) (resources.Space, v7action.Warnings, error) {
	fake.renameSpaceByNameAndOrganizationGUIDMutex.Lock()
	ret, specificReturn := fake.renameSpaceByNameAndOrganizationGUIDReturnsOnCall[len(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall)]
	fake.renameSpaceByNameAndOrganizationGUIDArgsForCall = append(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("RenameSpaceByNameAndOrganizationGUID", []interface{}{arg1, arg2, arg3})
	fake.renameSpaceByNameAndOrganizationGUIDMutex.Unlock()
	if fake.RenameSpaceByNameAndOrganizationGUIDStub != nil {
		return fake.RenameSpaceByNameAndOrganizationGUIDStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.renameSpaceByNameAndOrganizationGUIDReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDCallCount() int {
	fake.renameSpaceByNameAndOrganizationGUIDMutex.RLock()
	defer fake.renameSpaceByNameAndOrganizationGUIDMutex.RUnlock()
	return len(fake.renameSpaceByNameAndOrganizationGUIDArgsForCall)
}

func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDCalls(stub func(string, string, string) (resources.Space, v7action.Warnings, error)) {
	fake.renameSpaceByNameAndOrganizationGUIDMutex.Lock()
	defer fake.renameSpaceByNameAndOrganizationGUIDMutex.Unlock()
	fake.RenameSpaceByNameAndOrganizationGUIDStub = stub
}

func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDArgsForCall(i int) (string, string, string) {
	fake.renameSpaceByNameAndOrganizationGUIDMutex.RLock()
	defer fake.renameSpaceByNameAndOrganizationGUIDMutex.RUnlock()
	argsForCall := fake.renameSpaceByNameAndOrganizationGUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDReturns(result1 resources.Space, result2 v7action.Warnings, result3 error) {
	fake.renameSpaceByNameAndOrganizationGUIDMutex.Lock()
	defer fake.renameSpaceByNameAndOrganizationGUIDMutex.Unlock()
	fake.RenameSpaceByNameAndOrganizationGUIDStub = nil
	fake.renameSpaceByNameAndOrganizationGUIDReturns = struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) RenameSpaceByNameAndOrganizationGUIDReturnsOnCall(i int, result1 resources.Space, result2 v7action.Warnings, result3 error) {
	fake.renameSpaceByNameAndOrganizationGUIDMutex.Lock()
	defer fake.renameSpaceByNameAndOrganizationGUIDMutex.Unlock()
	fake.RenameSpaceByNameAndOrganizationGUIDStub = nil
	if fake.renameSpaceByNameAndOrganizationGUIDReturnsOnCall == nil {
		fake.renameSpaceByNameAndOrganizationGUIDReturnsOnCall = make(map[int]struct {
			result1 resources.Space
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.renameSpaceByNameAndOrganizationGUIDReturnsOnCall[i] = struct {
		result1 resources.Space
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) ResetOrganizationDefaultIsolationSegment(arg1 string) (v7action.Warnings, error) {
	fake.resetOrganizationDefaultIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.resetOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.resetOrganizationDefaultIsolationSegmentArgsForCall)]
	fake.resetOrganizationDefaultIsolationSegmentArgsForCall = append(fake.resetOrganizationDefaultIsolationSegmentArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("ResetOrganizationDefaultIsolationSegment", []interface{}{arg1})
	fake.resetOrganizationDefaultIsolationSegmentMutex.Unlock()
	if fake.ResetOrganizationDefaultIsolationSegmentStub != nil {
		return fake.ResetOrganizationDefaultIsolationSegmentStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.resetOrganizationDefaultIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentCallCount() int {
	fake.resetOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.resetOrganizationDefaultIsolationSegmentMutex.RUnlock()
	return len(fake.resetOrganizationDefaultIsolationSegmentArgsForCall)
}

func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentCalls(stub func(string) (v7action.Warnings, error)) {
	fake.resetOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.resetOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.ResetOrganizationDefaultIsolationSegmentStub = stub
}

func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentArgsForCall(i int) string {
	fake.resetOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.resetOrganizationDefaultIsolationSegmentMutex.RUnlock()
	argsForCall := fake.resetOrganizationDefaultIsolationSegmentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentReturns(result1 v7action.Warnings, result2 error) {
	fake.resetOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.resetOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.ResetOrganizationDefaultIsolationSegmentStub = nil
	fake.resetOrganizationDefaultIsolationSegmentReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ResetOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.resetOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.resetOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.ResetOrganizationDefaultIsolationSegmentStub = nil
	if fake.resetOrganizationDefaultIsolationSegmentReturnsOnCall == nil {
		fake.resetOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.resetOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ResetSpaceIsolationSegment(arg1 string, arg2 string) (string, v7action.Warnings, error) {
	fake.resetSpaceIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.resetSpaceIsolationSegmentReturnsOnCall[len(fake.resetSpaceIsolationSegmentArgsForCall)]
	fake.resetSpaceIsolationSegmentArgsForCall = append(fake.resetSpaceIsolationSegmentArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("ResetSpaceIsolationSegment", []interface{}{arg1, arg2})
	fake.resetSpaceIsolationSegmentMutex.Unlock()
	if fake.ResetSpaceIsolationSegmentStub != nil {
		return fake.ResetSpaceIsolationSegmentStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.resetSpaceIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) ResetSpaceIsolationSegmentCallCount() int {
	fake.resetSpaceIsolationSegmentMutex.RLock()
	defer fake.resetSpaceIsolationSegmentMutex.RUnlock()
	return len(fake.resetSpaceIsolationSegmentArgsForCall)
}

func (fake *FakeActor) ResetSpaceIsolationSegmentCalls(stub func(string, string) (string, v7action.Warnings, error)) {
	fake.resetSpaceIsolationSegmentMutex.Lock()
	defer fake.resetSpaceIsolationSegmentMutex.Unlock()
	fake.ResetSpaceIsolationSegmentStub = stub
}

func (fake *FakeActor) ResetSpaceIsolationSegmentArgsForCall(i int) (string, string) {
	fake.resetSpaceIsolationSegmentMutex.RLock()
	defer fake.resetSpaceIsolationSegmentMutex.RUnlock()
	argsForCall := fake.resetSpaceIsolationSegmentArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) ResetSpaceIsolationSegmentReturns(result1 string, result2 v7action.Warnings, result3 error) {
	fake.resetSpaceIsolationSegmentMutex.Lock()
	defer fake.resetSpaceIsolationSegmentMutex.Unlock()
	fake.ResetSpaceIsolationSegmentStub = nil
	fake.resetSpaceIsolationSegmentReturns = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) ResetSpaceIsolationSegmentReturnsOnCall(i int, result1 string, result2 v7action.Warnings, result3 error) {
	fake.resetSpaceIsolationSegmentMutex.Lock()
	defer fake.resetSpaceIsolationSegmentMutex.Unlock()
	fake.ResetSpaceIsolationSegmentStub = nil
	if fake.resetSpaceIsolationSegmentReturnsOnCall == nil {
		fake.resetSpaceIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 string
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.resetSpaceIsolationSegmentReturnsOnCall[i] = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) ResourceMatch(arg1 []sharedaction.V3Resource) ([]sharedaction.V3Resource, v7action.Warnings, error) {
	var arg1Copy []sharedaction.V3Resource
	if arg1 != nil {
		arg1Copy = make([]sharedaction.V3Resource, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.resourceMatchMutex.Lock()
	ret, specificReturn := fake.resourceMatchReturnsOnCall[len(fake.resourceMatchArgsForCall)]
	fake.resourceMatchArgsForCall = append(fake.resourceMatchArgsForCall, struct {
		arg1 []sharedaction.V3Resource
	}{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 *FakeActor) ResourceMatchCallCount() int {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	return len(fake.resourceMatchArgsForCall)
}

func (fake *FakeActor) ResourceMatchCalls(stub func([]sharedaction.V3Resource) ([]sharedaction.V3Resource, v7action.Warnings, error)) {
	fake.resourceMatchMutex.Lock()
	defer fake.resourceMatchMutex.Unlock()
	fake.ResourceMatchStub = stub
}

func (fake *FakeActor) ResourceMatchArgsForCall(i int) []sharedaction.V3Resource {
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	argsForCall := fake.resourceMatchArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) ResourceMatchReturns(result1 []sharedaction.V3Resource, result2 v7action.Warnings, result3 error) {
	fake.resourceMatchMutex.Lock()
	defer fake.resourceMatchMutex.Unlock()
	fake.ResourceMatchStub = nil
	fake.resourceMatchReturns = struct {
		result1 []sharedaction.V3Resource
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

func (fake *FakeActor) RestartApplication(arg1 string, arg2 bool) (v7action.Warnings, error) {
	fake.restartApplicationMutex.Lock()
	ret, specificReturn := fake.restartApplicationReturnsOnCall[len(fake.restartApplicationArgsForCall)]
	fake.restartApplicationArgsForCall = append(fake.restartApplicationArgsForCall, struct {
		arg1 string
		arg2 bool
	}{arg1, arg2})
	fake.recordInvocation("RestartApplication", []interface{}{arg1, arg2})
	fake.restartApplicationMutex.Unlock()
	if fake.RestartApplicationStub != nil {
		return fake.RestartApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.restartApplicationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) RestartApplicationCallCount() int {
	fake.restartApplicationMutex.RLock()
	defer fake.restartApplicationMutex.RUnlock()
	return len(fake.restartApplicationArgsForCall)
}

func (fake *FakeActor) RestartApplicationCalls(stub func(string, bool) (v7action.Warnings, error)) {
	fake.restartApplicationMutex.Lock()
	defer fake.restartApplicationMutex.Unlock()
	fake.RestartApplicationStub = stub
}

func (fake *FakeActor) RestartApplicationArgsForCall(i int) (string, bool) {
	fake.restartApplicationMutex.RLock()
	defer fake.restartApplicationMutex.RUnlock()
	argsForCall := fake.restartApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) RestartApplicationReturns(result1 v7action.Warnings, result2 error) {
	fake.restartApplicationMutex.Lock()
	defer fake.restartApplicationMutex.Unlock()
	fake.RestartApplicationStub = nil
	fake.restartApplicationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RestartApplicationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.restartApplicationMutex.Lock()
	defer fake.restartApplicationMutex.Unlock()
	fake.RestartApplicationStub = nil
	if fake.restartApplicationReturnsOnCall == nil {
		fake.restartApplicationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.restartApplicationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) RevokeAccessAndRefreshTokens() error {
	fake.revokeAccessAndRefreshTokensMutex.Lock()
	ret, specificReturn := fake.revokeAccessAndRefreshTokensReturnsOnCall[len(fake.revokeAccessAndRefreshTokensArgsForCall)]
	fake.revokeAccessAndRefreshTokensArgsForCall = append(fake.revokeAccessAndRefreshTokensArgsForCall, struct {
	}{})
	fake.recordInvocation("RevokeAccessAndRefreshTokens", []interface{}{})
	fake.revokeAccessAndRefreshTokensMutex.Unlock()
	if fake.RevokeAccessAndRefreshTokensStub != nil {
		return fake.RevokeAccessAndRefreshTokensStub()
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.revokeAccessAndRefreshTokensReturns
	return fakeReturns.result1
}

func (fake *FakeActor) RevokeAccessAndRefreshTokensCallCount() int {
	fake.revokeAccessAndRefreshTokensMutex.RLock()
	defer fake.revokeAccessAndRefreshTokensMutex.RUnlock()
	return len(fake.revokeAccessAndRefreshTokensArgsForCall)
}

func (fake *FakeActor) RevokeAccessAndRefreshTokensCalls(stub func() error) {
	fake.revokeAccessAndRefreshTokensMutex.Lock()
	defer fake.revokeAccessAndRefreshTokensMutex.Unlock()
	fake.RevokeAccessAndRefreshTokensStub = stub
}

func (fake *FakeActor) RevokeAccessAndRefreshTokensReturns(result1 error) {
	fake.revokeAccessAndRefreshTokensMutex.Lock()
	defer fake.revokeAccessAndRefreshTokensMutex.Unlock()
	fake.RevokeAccessAndRefreshTokensStub = nil
	fake.revokeAccessAndRefreshTokensReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeActor) RevokeAccessAndRefreshTokensReturnsOnCall(i int, result1 error) {
	fake.revokeAccessAndRefreshTokensMutex.Lock()
	defer fake.revokeAccessAndRefreshTokensMutex.Unlock()
	fake.RevokeAccessAndRefreshTokensStub = nil
	if fake.revokeAccessAndRefreshTokensReturnsOnCall == nil {
		fake.revokeAccessAndRefreshTokensReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.revokeAccessAndRefreshTokensReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeActor) RunTask(arg1 string, arg2 resources.Task) (resources.Task, v7action.Warnings, error) {
	fake.runTaskMutex.Lock()
	ret, specificReturn := fake.runTaskReturnsOnCall[len(fake.runTaskArgsForCall)]
	fake.runTaskArgsForCall = append(fake.runTaskArgsForCall, struct {
		arg1 string
		arg2 resources.Task
	}{arg1, arg2})
	fake.recordInvocation("RunTask", []interface{}{arg1, arg2})
	fake.runTaskMutex.Unlock()
	if fake.RunTaskStub != nil {
		return fake.RunTaskStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.runTaskReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) RunTaskCallCount() int {
	fake.runTaskMutex.RLock()
	defer fake.runTaskMutex.RUnlock()
	return len(fake.runTaskArgsForCall)
}

func (fake *FakeActor) RunTaskCalls(stub func(string, resources.Task) (resources.Task, v7action.Warnings, error)) {
	fake.runTaskMutex.Lock()
	defer fake.runTaskMutex.Unlock()
	fake.RunTaskStub = stub
}

func (fake *FakeActor) RunTaskArgsForCall(i int) (string, resources.Task) {
	fake.runTaskMutex.RLock()
	defer fake.runTaskMutex.RUnlock()
	argsForCall := fake.runTaskArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) RunTaskReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.runTaskMutex.Lock()
	defer fake.runTaskMutex.Unlock()
	fake.RunTaskStub = nil
	fake.runTaskReturns = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) RunTaskReturnsOnCall(i int, result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.runTaskMutex.Lock()
	defer fake.runTaskMutex.Unlock()
	fake.RunTaskStub = nil
	if fake.runTaskReturnsOnCall == nil {
		fake.runTaskReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.runTaskReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) ScaleProcessByApplication(arg1 string, arg2 resources.Process) (v7action.Warnings, error) {
	fake.scaleProcessByApplicationMutex.Lock()
	ret, specificReturn := fake.scaleProcessByApplicationReturnsOnCall[len(fake.scaleProcessByApplicationArgsForCall)]
	fake.scaleProcessByApplicationArgsForCall = append(fake.scaleProcessByApplicationArgsForCall, struct {
		arg1 string
		arg2 resources.Process
	}{arg1, arg2})
	fake.recordInvocation("ScaleProcessByApplication", []interface{}{arg1, arg2})
	fake.scaleProcessByApplicationMutex.Unlock()
	if fake.ScaleProcessByApplicationStub != nil {
		return fake.ScaleProcessByApplicationStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.scaleProcessByApplicationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ScaleProcessByApplicationCallCount() int {
	fake.scaleProcessByApplicationMutex.RLock()
	defer fake.scaleProcessByApplicationMutex.RUnlock()
	return len(fake.scaleProcessByApplicationArgsForCall)
}

func (fake *FakeActor) ScaleProcessByApplicationCalls(stub func(string, resources.Process) (v7action.Warnings, error)) {
	fake.scaleProcessByApplicationMutex.Lock()
	defer fake.scaleProcessByApplicationMutex.Unlock()
	fake.ScaleProcessByApplicationStub = stub
}

func (fake *FakeActor) ScaleProcessByApplicationArgsForCall(i int) (string, resources.Process) {
	fake.scaleProcessByApplicationMutex.RLock()
	defer fake.scaleProcessByApplicationMutex.RUnlock()
	argsForCall := fake.scaleProcessByApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) ScaleProcessByApplicationReturns(result1 v7action.Warnings, result2 error) {
	fake.scaleProcessByApplicationMutex.Lock()
	defer fake.scaleProcessByApplicationMutex.Unlock()
	fake.ScaleProcessByApplicationStub = nil
	fake.scaleProcessByApplicationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ScaleProcessByApplicationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.scaleProcessByApplicationMutex.Lock()
	defer fake.scaleProcessByApplicationMutex.Unlock()
	fake.ScaleProcessByApplicationStub = nil
	if fake.scaleProcessByApplicationReturnsOnCall == nil {
		fake.scaleProcessByApplicationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.scaleProcessByApplicationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ScheduleTokenRefresh(arg1 func(time.Duration) <-chan time.Time, arg2 chan struct{}, arg3 chan struct{}) (<-chan error, error) {
	fake.scheduleTokenRefreshMutex.Lock()
	ret, specificReturn := fake.scheduleTokenRefreshReturnsOnCall[len(fake.scheduleTokenRefreshArgsForCall)]
	fake.scheduleTokenRefreshArgsForCall = append(fake.scheduleTokenRefreshArgsForCall, struct {
		arg1 func(time.Duration) <-chan time.Time
		arg2 chan struct{}
		arg3 chan struct{}
	}{arg1, arg2, arg3})
	fake.recordInvocation("ScheduleTokenRefresh", []interface{}{arg1, arg2, arg3})
	fake.scheduleTokenRefreshMutex.Unlock()
	if fake.ScheduleTokenRefreshStub != nil {
		return fake.ScheduleTokenRefreshStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.scheduleTokenRefreshReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ScheduleTokenRefreshCallCount() int {
	fake.scheduleTokenRefreshMutex.RLock()
	defer fake.scheduleTokenRefreshMutex.RUnlock()
	return len(fake.scheduleTokenRefreshArgsForCall)
}

func (fake *FakeActor) ScheduleTokenRefreshCalls(stub func(func(time.Duration) <-chan time.Time, chan struct{}, chan struct{}) (<-chan error, error)) {
	fake.scheduleTokenRefreshMutex.Lock()
	defer fake.scheduleTokenRefreshMutex.Unlock()
	fake.ScheduleTokenRefreshStub = stub
}

func (fake *FakeActor) ScheduleTokenRefreshArgsForCall(i int) (func(time.Duration) <-chan time.Time, chan struct{}, chan struct{}) {
	fake.scheduleTokenRefreshMutex.RLock()
	defer fake.scheduleTokenRefreshMutex.RUnlock()
	argsForCall := fake.scheduleTokenRefreshArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) ScheduleTokenRefreshReturns(result1 <-chan error, result2 error) {
	fake.scheduleTokenRefreshMutex.Lock()
	defer fake.scheduleTokenRefreshMutex.Unlock()
	fake.ScheduleTokenRefreshStub = nil
	fake.scheduleTokenRefreshReturns = struct {
		result1 <-chan error
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ScheduleTokenRefreshReturnsOnCall(i int, result1 <-chan error, result2 error) {
	fake.scheduleTokenRefreshMutex.Lock()
	defer fake.scheduleTokenRefreshMutex.Unlock()
	fake.ScheduleTokenRefreshStub = nil
	if fake.scheduleTokenRefreshReturnsOnCall == nil {
		fake.scheduleTokenRefreshReturnsOnCall = make(map[int]struct {
			result1 <-chan error
			result2 error
		})
	}
	fake.scheduleTokenRefreshReturnsOnCall[i] = struct {
		result1 <-chan error
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetApplicationDroplet(arg1 string, arg2 string) (v7action.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
	}
	fakeReturns := fake.setApplicationDropletReturns
	return fakeReturns.result1, fakeReturns.result2
}

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

func (fake *FakeActor) SetApplicationDropletCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = stub
}

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

func (fake *FakeActor) SetApplicationDropletReturns(result1 v7action.Warnings, result2 error) {
	fake.setApplicationDropletMutex.Lock()
	defer fake.setApplicationDropletMutex.Unlock()
	fake.SetApplicationDropletStub = nil
	fake.setApplicationDropletReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpace(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.setApplicationDropletByApplicationNameAndSpaceReturnsOnCall[len(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall)]
	fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall = append(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("SetApplicationDropletByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.Unlock()
	if fake.SetApplicationDropletByApplicationNameAndSpaceStub != nil {
		return fake.SetApplicationDropletByApplicationNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setApplicationDropletByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceCallCount() int {
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.RLock()
	defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.Lock()
	defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.Unlock()
	fake.SetApplicationDropletByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceArgsForCall(i int) (string, string, string) {
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.RLock()
	defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.setApplicationDropletByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceReturns(result1 v7action.Warnings, result2 error) {
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.Lock()
	defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.Unlock()
	fake.SetApplicationDropletByApplicationNameAndSpaceStub = nil
	fake.setApplicationDropletByApplicationNameAndSpaceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetApplicationDropletByApplicationNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.Lock()
	defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.Unlock()
	fake.SetApplicationDropletByApplicationNameAndSpaceStub = nil
	if fake.setApplicationDropletByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.setApplicationDropletByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setApplicationDropletByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetApplicationManifest(arg1 string, arg2 []byte) (v7action.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.setApplicationManifestMutex.Lock()
	ret, specificReturn := fake.setApplicationManifestReturnsOnCall[len(fake.setApplicationManifestArgsForCall)]
	fake.setApplicationManifestArgsForCall = append(fake.setApplicationManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	fake.recordInvocation("SetApplicationManifest", []interface{}{arg1, arg2Copy})
	fake.setApplicationManifestMutex.Unlock()
	if fake.SetApplicationManifestStub != nil {
		return fake.SetApplicationManifestStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setApplicationManifestReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetApplicationManifestCallCount() int {
	fake.setApplicationManifestMutex.RLock()
	defer fake.setApplicationManifestMutex.RUnlock()
	return len(fake.setApplicationManifestArgsForCall)
}

func (fake *FakeActor) SetApplicationManifestCalls(stub func(string, []byte) (v7action.Warnings, error)) {
	fake.setApplicationManifestMutex.Lock()
	defer fake.setApplicationManifestMutex.Unlock()
	fake.SetApplicationManifestStub = stub
}

func (fake *FakeActor) SetApplicationManifestArgsForCall(i int) (string, []byte) {
	fake.setApplicationManifestMutex.RLock()
	defer fake.setApplicationManifestMutex.RUnlock()
	argsForCall := fake.setApplicationManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) SetApplicationManifestReturns(result1 v7action.Warnings, result2 error) {
	fake.setApplicationManifestMutex.Lock()
	defer fake.setApplicationManifestMutex.Unlock()
	fake.SetApplicationManifestStub = nil
	fake.setApplicationManifestReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetApplicationManifestReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setApplicationManifestMutex.Lock()
	defer fake.setApplicationManifestMutex.Unlock()
	fake.SetApplicationManifestStub = nil
	if fake.setApplicationManifestReturnsOnCall == nil {
		fake.setApplicationManifestReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setApplicationManifestReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpace(arg1 string, arg2 string, arg3 constanta.HealthCheckType, arg4 string, arg5 string, arg6 int64) (resources.Application, v7action.Warnings, error) {
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall[len(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall)]
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall = append(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 constanta.HealthCheckType
		arg4 string
		arg5 string
		arg6 int64
	}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.recordInvocation("SetApplicationProcessHealthCheckTypeByNameAndSpace", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Unlock()
	if fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub != nil {
		return fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceCallCount() int {
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RLock()
	defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RUnlock()
	return len(fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceCalls(stub func(string, string, constanta.HealthCheckType, string, string, int64) (resources.Application, v7action.Warnings, error)) {
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Lock()
	defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Unlock()
	fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub = stub
}

func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall(i int) (string, string, constanta.HealthCheckType, string, string, int64) {
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RLock()
	defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RUnlock()
	argsForCall := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceReturns(result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Lock()
	defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Unlock()
	fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub = nil
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturns = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) SetApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall(i int, result1 resources.Application, result2 v7action.Warnings, result3 error) {
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Lock()
	defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Unlock()
	fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub = nil
	if fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall == nil {
		fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpace(arg1 string, arg2 string, arg3 v7action.EnvironmentVariablePair) (v7action.Warnings, error) {
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.setEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall[len(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall)]
	fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall = append(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 v7action.EnvironmentVariablePair
	}{arg1, arg2, arg3})
	fake.recordInvocation("SetEnvironmentVariableByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	if fake.SetEnvironmentVariableByApplicationNameAndSpaceStub != nil {
		return fake.SetEnvironmentVariableByApplicationNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setEnvironmentVariableByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceCallCount() int {
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RLock()
	defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceCalls(stub func(string, string, v7action.EnvironmentVariablePair) (v7action.Warnings, error)) {
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	fake.SetEnvironmentVariableByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceArgsForCall(i int) (string, string, v7action.EnvironmentVariablePair) {
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RLock()
	defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.setEnvironmentVariableByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceReturns(result1 v7action.Warnings, result2 error) {
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	fake.SetEnvironmentVariableByApplicationNameAndSpaceStub = nil
	fake.setEnvironmentVariableByApplicationNameAndSpaceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	fake.SetEnvironmentVariableByApplicationNameAndSpaceStub = nil
	if fake.setEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.setEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetEnvironmentVariableGroup(arg1 constanta.EnvironmentVariableGroupName, arg2 resources.EnvironmentVariables) (v7action.Warnings, error) {
	fake.setEnvironmentVariableGroupMutex.Lock()
	ret, specificReturn := fake.setEnvironmentVariableGroupReturnsOnCall[len(fake.setEnvironmentVariableGroupArgsForCall)]
	fake.setEnvironmentVariableGroupArgsForCall = append(fake.setEnvironmentVariableGroupArgsForCall, struct {
		arg1 constanta.EnvironmentVariableGroupName
		arg2 resources.EnvironmentVariables
	}{arg1, arg2})
	fake.recordInvocation("SetEnvironmentVariableGroup", []interface{}{arg1, arg2})
	fake.setEnvironmentVariableGroupMutex.Unlock()
	if fake.SetEnvironmentVariableGroupStub != nil {
		return fake.SetEnvironmentVariableGroupStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setEnvironmentVariableGroupReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetEnvironmentVariableGroupCallCount() int {
	fake.setEnvironmentVariableGroupMutex.RLock()
	defer fake.setEnvironmentVariableGroupMutex.RUnlock()
	return len(fake.setEnvironmentVariableGroupArgsForCall)
}

func (fake *FakeActor) SetEnvironmentVariableGroupCalls(stub func(constanta.EnvironmentVariableGroupName, resources.EnvironmentVariables) (v7action.Warnings, error)) {
	fake.setEnvironmentVariableGroupMutex.Lock()
	defer fake.setEnvironmentVariableGroupMutex.Unlock()
	fake.SetEnvironmentVariableGroupStub = stub
}

func (fake *FakeActor) SetEnvironmentVariableGroupArgsForCall(i int) (constanta.EnvironmentVariableGroupName, resources.EnvironmentVariables) {
	fake.setEnvironmentVariableGroupMutex.RLock()
	defer fake.setEnvironmentVariableGroupMutex.RUnlock()
	argsForCall := fake.setEnvironmentVariableGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) SetEnvironmentVariableGroupReturns(result1 v7action.Warnings, result2 error) {
	fake.setEnvironmentVariableGroupMutex.Lock()
	defer fake.setEnvironmentVariableGroupMutex.Unlock()
	fake.SetEnvironmentVariableGroupStub = nil
	fake.setEnvironmentVariableGroupReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetEnvironmentVariableGroupReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setEnvironmentVariableGroupMutex.Lock()
	defer fake.setEnvironmentVariableGroupMutex.Unlock()
	fake.SetEnvironmentVariableGroupStub = nil
	if fake.setEnvironmentVariableGroupReturnsOnCall == nil {
		fake.setEnvironmentVariableGroupReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setEnvironmentVariableGroupReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetOrganizationDefaultIsolationSegment(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.setOrganizationDefaultIsolationSegmentMutex.Lock()
	ret, specificReturn := fake.setOrganizationDefaultIsolationSegmentReturnsOnCall[len(fake.setOrganizationDefaultIsolationSegmentArgsForCall)]
	fake.setOrganizationDefaultIsolationSegmentArgsForCall = append(fake.setOrganizationDefaultIsolationSegmentArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("SetOrganizationDefaultIsolationSegment", []interface{}{arg1, arg2})
	fake.setOrganizationDefaultIsolationSegmentMutex.Unlock()
	if fake.SetOrganizationDefaultIsolationSegmentStub != nil {
		return fake.SetOrganizationDefaultIsolationSegmentStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setOrganizationDefaultIsolationSegmentReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentCallCount() int {
	fake.setOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock()
	return len(fake.setOrganizationDefaultIsolationSegmentArgsForCall)
}

func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.setOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.SetOrganizationDefaultIsolationSegmentStub = stub
}

func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentArgsForCall(i int) (string, string) {
	fake.setOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock()
	argsForCall := fake.setOrganizationDefaultIsolationSegmentArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentReturns(result1 v7action.Warnings, result2 error) {
	fake.setOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.SetOrganizationDefaultIsolationSegmentStub = nil
	fake.setOrganizationDefaultIsolationSegmentReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetOrganizationDefaultIsolationSegmentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setOrganizationDefaultIsolationSegmentMutex.Lock()
	defer fake.setOrganizationDefaultIsolationSegmentMutex.Unlock()
	fake.SetOrganizationDefaultIsolationSegmentStub = nil
	if fake.setOrganizationDefaultIsolationSegmentReturnsOnCall == nil {
		fake.setOrganizationDefaultIsolationSegmentReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setOrganizationDefaultIsolationSegmentReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetSpaceManifest(arg1 string, arg2 []byte) (v7action.Warnings, error) {
	var arg2Copy []byte
	if arg2 != nil {
		arg2Copy = make([]byte, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.setSpaceManifestMutex.Lock()
	ret, specificReturn := fake.setSpaceManifestReturnsOnCall[len(fake.setSpaceManifestArgsForCall)]
	fake.setSpaceManifestArgsForCall = append(fake.setSpaceManifestArgsForCall, struct {
		arg1 string
		arg2 []byte
	}{arg1, arg2Copy})
	fake.recordInvocation("SetSpaceManifest", []interface{}{arg1, arg2Copy})
	fake.setSpaceManifestMutex.Unlock()
	if fake.SetSpaceManifestStub != nil {
		return fake.SetSpaceManifestStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setSpaceManifestReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetSpaceManifestCallCount() int {
	fake.setSpaceManifestMutex.RLock()
	defer fake.setSpaceManifestMutex.RUnlock()
	return len(fake.setSpaceManifestArgsForCall)
}

func (fake *FakeActor) SetSpaceManifestCalls(stub func(string, []byte) (v7action.Warnings, error)) {
	fake.setSpaceManifestMutex.Lock()
	defer fake.setSpaceManifestMutex.Unlock()
	fake.SetSpaceManifestStub = stub
}

func (fake *FakeActor) SetSpaceManifestArgsForCall(i int) (string, []byte) {
	fake.setSpaceManifestMutex.RLock()
	defer fake.setSpaceManifestMutex.RUnlock()
	argsForCall := fake.setSpaceManifestArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) SetSpaceManifestReturns(result1 v7action.Warnings, result2 error) {
	fake.setSpaceManifestMutex.Lock()
	defer fake.setSpaceManifestMutex.Unlock()
	fake.SetSpaceManifestStub = nil
	fake.setSpaceManifestReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetSpaceManifestReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setSpaceManifestMutex.Lock()
	defer fake.setSpaceManifestMutex.Unlock()
	fake.SetSpaceManifestStub = nil
	if fake.setSpaceManifestReturnsOnCall == nil {
		fake.setSpaceManifestReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setSpaceManifestReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetTarget(arg1 v7action.TargetSettings) (v7action.Warnings, error) {
	fake.setTargetMutex.Lock()
	ret, specificReturn := fake.setTargetReturnsOnCall[len(fake.setTargetArgsForCall)]
	fake.setTargetArgsForCall = append(fake.setTargetArgsForCall, struct {
		arg1 v7action.TargetSettings
	}{arg1})
	fake.recordInvocation("SetTarget", []interface{}{arg1})
	fake.setTargetMutex.Unlock()
	if fake.SetTargetStub != nil {
		return fake.SetTargetStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.setTargetReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SetTargetCallCount() int {
	fake.setTargetMutex.RLock()
	defer fake.setTargetMutex.RUnlock()
	return len(fake.setTargetArgsForCall)
}

func (fake *FakeActor) SetTargetCalls(stub func(v7action.TargetSettings) (v7action.Warnings, error)) {
	fake.setTargetMutex.Lock()
	defer fake.setTargetMutex.Unlock()
	fake.SetTargetStub = stub
}

func (fake *FakeActor) SetTargetArgsForCall(i int) v7action.TargetSettings {
	fake.setTargetMutex.RLock()
	defer fake.setTargetMutex.RUnlock()
	argsForCall := fake.setTargetArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) SetTargetReturns(result1 v7action.Warnings, result2 error) {
	fake.setTargetMutex.Lock()
	defer fake.setTargetMutex.Unlock()
	fake.SetTargetStub = nil
	fake.setTargetReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SetTargetReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.setTargetMutex.Lock()
	defer fake.setTargetMutex.Unlock()
	fake.SetTargetStub = nil
	if fake.setTargetReturnsOnCall == nil {
		fake.setTargetReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.setTargetReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SharePrivateDomain(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.sharePrivateDomainMutex.Lock()
	ret, specificReturn := fake.sharePrivateDomainReturnsOnCall[len(fake.sharePrivateDomainArgsForCall)]
	fake.sharePrivateDomainArgsForCall = append(fake.sharePrivateDomainArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("SharePrivateDomain", []interface{}{arg1, arg2})
	fake.sharePrivateDomainMutex.Unlock()
	if fake.SharePrivateDomainStub != nil {
		return fake.SharePrivateDomainStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.sharePrivateDomainReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) SharePrivateDomainCallCount() int {
	fake.sharePrivateDomainMutex.RLock()
	defer fake.sharePrivateDomainMutex.RUnlock()
	return len(fake.sharePrivateDomainArgsForCall)
}

func (fake *FakeActor) SharePrivateDomainCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.sharePrivateDomainMutex.Lock()
	defer fake.sharePrivateDomainMutex.Unlock()
	fake.SharePrivateDomainStub = stub
}

func (fake *FakeActor) SharePrivateDomainArgsForCall(i int) (string, string) {
	fake.sharePrivateDomainMutex.RLock()
	defer fake.sharePrivateDomainMutex.RUnlock()
	argsForCall := fake.sharePrivateDomainArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) SharePrivateDomainReturns(result1 v7action.Warnings, result2 error) {
	fake.sharePrivateDomainMutex.Lock()
	defer fake.sharePrivateDomainMutex.Unlock()
	fake.SharePrivateDomainStub = nil
	fake.sharePrivateDomainReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) SharePrivateDomainReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.sharePrivateDomainMutex.Lock()
	defer fake.sharePrivateDomainMutex.Unlock()
	fake.SharePrivateDomainStub = nil
	if fake.sharePrivateDomainReturnsOnCall == nil {
		fake.sharePrivateDomainReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.sharePrivateDomainReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ShareRoute(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.shareRouteMutex.Lock()
	ret, specificReturn := fake.shareRouteReturnsOnCall[len(fake.shareRouteArgsForCall)]
	fake.shareRouteArgsForCall = append(fake.shareRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("ShareRoute", []interface{}{arg1, arg2})
	fake.shareRouteMutex.Unlock()
	if fake.ShareRouteStub != nil {
		return fake.ShareRouteStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.shareRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ShareRouteCallCount() int {
	fake.shareRouteMutex.RLock()
	defer fake.shareRouteMutex.RUnlock()
	return len(fake.shareRouteArgsForCall)
}

func (fake *FakeActor) ShareRouteCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.shareRouteMutex.Lock()
	defer fake.shareRouteMutex.Unlock()
	fake.ShareRouteStub = stub
}

func (fake *FakeActor) ShareRouteArgsForCall(i int) (string, string) {
	fake.shareRouteMutex.RLock()
	defer fake.shareRouteMutex.RUnlock()
	argsForCall := fake.shareRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) ShareRouteReturns(result1 v7action.Warnings, result2 error) {
	fake.shareRouteMutex.Lock()
	defer fake.shareRouteMutex.Unlock()
	fake.ShareRouteStub = nil
	fake.shareRouteReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ShareRouteReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.shareRouteMutex.Lock()
	defer fake.shareRouteMutex.Unlock()
	fake.ShareRouteStub = nil
	if fake.shareRouteReturnsOnCall == nil {
		fake.shareRouteReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.shareRouteReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrg(arg1 string, arg2 string, arg3 string, arg4 v7action.ServiceInstanceSharingParams) (v7action.Warnings, error) {
	fake.shareServiceInstanceToSpaceAndOrgMutex.Lock()
	ret, specificReturn := fake.shareServiceInstanceToSpaceAndOrgReturnsOnCall[len(fake.shareServiceInstanceToSpaceAndOrgArgsForCall)]
	fake.shareServiceInstanceToSpaceAndOrgArgsForCall = append(fake.shareServiceInstanceToSpaceAndOrgArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 v7action.ServiceInstanceSharingParams
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("ShareServiceInstanceToSpaceAndOrg", []interface{}{arg1, arg2, arg3, arg4})
	fake.shareServiceInstanceToSpaceAndOrgMutex.Unlock()
	if fake.ShareServiceInstanceToSpaceAndOrgStub != nil {
		return fake.ShareServiceInstanceToSpaceAndOrgStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.shareServiceInstanceToSpaceAndOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgCallCount() int {
	fake.shareServiceInstanceToSpaceAndOrgMutex.RLock()
	defer fake.shareServiceInstanceToSpaceAndOrgMutex.RUnlock()
	return len(fake.shareServiceInstanceToSpaceAndOrgArgsForCall)
}

func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgCalls(stub func(string, string, string, v7action.ServiceInstanceSharingParams) (v7action.Warnings, error)) {
	fake.shareServiceInstanceToSpaceAndOrgMutex.Lock()
	defer fake.shareServiceInstanceToSpaceAndOrgMutex.Unlock()
	fake.ShareServiceInstanceToSpaceAndOrgStub = stub
}

func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgArgsForCall(i int) (string, string, string, v7action.ServiceInstanceSharingParams) {
	fake.shareServiceInstanceToSpaceAndOrgMutex.RLock()
	defer fake.shareServiceInstanceToSpaceAndOrgMutex.RUnlock()
	argsForCall := fake.shareServiceInstanceToSpaceAndOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgReturns(result1 v7action.Warnings, result2 error) {
	fake.shareServiceInstanceToSpaceAndOrgMutex.Lock()
	defer fake.shareServiceInstanceToSpaceAndOrgMutex.Unlock()
	fake.ShareServiceInstanceToSpaceAndOrgStub = nil
	fake.shareServiceInstanceToSpaceAndOrgReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ShareServiceInstanceToSpaceAndOrgReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.shareServiceInstanceToSpaceAndOrgMutex.Lock()
	defer fake.shareServiceInstanceToSpaceAndOrgMutex.Unlock()
	fake.ShareServiceInstanceToSpaceAndOrgStub = nil
	if fake.shareServiceInstanceToSpaceAndOrgReturnsOnCall == nil {
		fake.shareServiceInstanceToSpaceAndOrgReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.shareServiceInstanceToSpaceAndOrgReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) StageApplicationPackage(arg1 string) (resources.Build, v7action.Warnings, error) {
	fake.stageApplicationPackageMutex.Lock()
	ret, specificReturn := fake.stageApplicationPackageReturnsOnCall[len(fake.stageApplicationPackageArgsForCall)]
	fake.stageApplicationPackageArgsForCall = append(fake.stageApplicationPackageArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("StageApplicationPackage", []interface{}{arg1})
	fake.stageApplicationPackageMutex.Unlock()
	if fake.StageApplicationPackageStub != nil {
		return fake.StageApplicationPackageStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.stageApplicationPackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) StageApplicationPackageCallCount() int {
	fake.stageApplicationPackageMutex.RLock()
	defer fake.stageApplicationPackageMutex.RUnlock()
	return len(fake.stageApplicationPackageArgsForCall)
}

func (fake *FakeActor) StageApplicationPackageCalls(stub func(string) (resources.Build, v7action.Warnings, error)) {
	fake.stageApplicationPackageMutex.Lock()
	defer fake.stageApplicationPackageMutex.Unlock()
	fake.StageApplicationPackageStub = stub
}

func (fake *FakeActor) StageApplicationPackageArgsForCall(i int) string {
	fake.stageApplicationPackageMutex.RLock()
	defer fake.stageApplicationPackageMutex.RUnlock()
	argsForCall := fake.stageApplicationPackageArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) StageApplicationPackageReturns(result1 resources.Build, result2 v7action.Warnings, result3 error) {
	fake.stageApplicationPackageMutex.Lock()
	defer fake.stageApplicationPackageMutex.Unlock()
	fake.StageApplicationPackageStub = nil
	fake.stageApplicationPackageReturns = struct {
		result1 resources.Build
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) StageApplicationPackageReturnsOnCall(i int, result1 resources.Build, result2 v7action.Warnings, result3 error) {
	fake.stageApplicationPackageMutex.Lock()
	defer fake.stageApplicationPackageMutex.Unlock()
	fake.StageApplicationPackageStub = nil
	if fake.stageApplicationPackageReturnsOnCall == nil {
		fake.stageApplicationPackageReturnsOnCall = make(map[int]struct {
			result1 resources.Build
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.stageApplicationPackageReturnsOnCall[i] = struct {
		result1 resources.Build
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) StagePackage(arg1 string, arg2 string, arg3 string) (<-chan resources.Droplet, <-chan v7action.Warnings, <-chan error) {
	fake.stagePackageMutex.Lock()
	ret, specificReturn := fake.stagePackageReturnsOnCall[len(fake.stagePackageArgsForCall)]
	fake.stagePackageArgsForCall = append(fake.stagePackageArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("StagePackage", []interface{}{arg1, arg2, arg3})
	fake.stagePackageMutex.Unlock()
	if fake.StagePackageStub != nil {
		return fake.StagePackageStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.stagePackageReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) StagePackageCallCount() int {
	fake.stagePackageMutex.RLock()
	defer fake.stagePackageMutex.RUnlock()
	return len(fake.stagePackageArgsForCall)
}

func (fake *FakeActor) StagePackageCalls(stub func(string, string, string) (<-chan resources.Droplet, <-chan v7action.Warnings, <-chan error)) {
	fake.stagePackageMutex.Lock()
	defer fake.stagePackageMutex.Unlock()
	fake.StagePackageStub = stub
}

func (fake *FakeActor) StagePackageArgsForCall(i int) (string, string, string) {
	fake.stagePackageMutex.RLock()
	defer fake.stagePackageMutex.RUnlock()
	argsForCall := fake.stagePackageArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) StagePackageReturns(result1 <-chan resources.Droplet, result2 <-chan v7action.Warnings, result3 <-chan error) {
	fake.stagePackageMutex.Lock()
	defer fake.stagePackageMutex.Unlock()
	fake.StagePackageStub = nil
	fake.stagePackageReturns = struct {
		result1 <-chan resources.Droplet
		result2 <-chan v7action.Warnings
		result3 <-chan error
	}{result1, result2, result3}
}

func (fake *FakeActor) StagePackageReturnsOnCall(i int, result1 <-chan resources.Droplet, result2 <-chan v7action.Warnings, result3 <-chan error) {
	fake.stagePackageMutex.Lock()
	defer fake.stagePackageMutex.Unlock()
	fake.StagePackageStub = nil
	if fake.stagePackageReturnsOnCall == nil {
		fake.stagePackageReturnsOnCall = make(map[int]struct {
			result1 <-chan resources.Droplet
			result2 <-chan v7action.Warnings
			result3 <-chan error
		})
	}
	fake.stagePackageReturnsOnCall[i] = struct {
		result1 <-chan resources.Droplet
		result2 <-chan v7action.Warnings
		result3 <-chan error
	}{result1, result2, result3}
}

func (fake *FakeActor) StartApplication(arg1 string) (v7action.Warnings, error) {
	fake.startApplicationMutex.Lock()
	ret, specificReturn := fake.startApplicationReturnsOnCall[len(fake.startApplicationArgsForCall)]
	fake.startApplicationArgsForCall = append(fake.startApplicationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("StartApplication", []interface{}{arg1})
	fake.startApplicationMutex.Unlock()
	if fake.StartApplicationStub != nil {
		return fake.StartApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.startApplicationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) StartApplicationCallCount() int {
	fake.startApplicationMutex.RLock()
	defer fake.startApplicationMutex.RUnlock()
	return len(fake.startApplicationArgsForCall)
}

func (fake *FakeActor) StartApplicationCalls(stub func(string) (v7action.Warnings, error)) {
	fake.startApplicationMutex.Lock()
	defer fake.startApplicationMutex.Unlock()
	fake.StartApplicationStub = stub
}

func (fake *FakeActor) StartApplicationArgsForCall(i int) string {
	fake.startApplicationMutex.RLock()
	defer fake.startApplicationMutex.RUnlock()
	argsForCall := fake.startApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) StartApplicationReturns(result1 v7action.Warnings, result2 error) {
	fake.startApplicationMutex.Lock()
	defer fake.startApplicationMutex.Unlock()
	fake.StartApplicationStub = nil
	fake.startApplicationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) StartApplicationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.startApplicationMutex.Lock()
	defer fake.startApplicationMutex.Unlock()
	fake.StartApplicationStub = nil
	if fake.startApplicationReturnsOnCall == nil {
		fake.startApplicationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.startApplicationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) StopApplication(arg1 string) (v7action.Warnings, error) {
	fake.stopApplicationMutex.Lock()
	ret, specificReturn := fake.stopApplicationReturnsOnCall[len(fake.stopApplicationArgsForCall)]
	fake.stopApplicationArgsForCall = append(fake.stopApplicationArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("StopApplication", []interface{}{arg1})
	fake.stopApplicationMutex.Unlock()
	if fake.StopApplicationStub != nil {
		return fake.StopApplicationStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.stopApplicationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) StopApplicationCallCount() int {
	fake.stopApplicationMutex.RLock()
	defer fake.stopApplicationMutex.RUnlock()
	return len(fake.stopApplicationArgsForCall)
}

func (fake *FakeActor) StopApplicationCalls(stub func(string) (v7action.Warnings, error)) {
	fake.stopApplicationMutex.Lock()
	defer fake.stopApplicationMutex.Unlock()
	fake.StopApplicationStub = stub
}

func (fake *FakeActor) StopApplicationArgsForCall(i int) string {
	fake.stopApplicationMutex.RLock()
	defer fake.stopApplicationMutex.RUnlock()
	argsForCall := fake.stopApplicationArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) StopApplicationReturns(result1 v7action.Warnings, result2 error) {
	fake.stopApplicationMutex.Lock()
	defer fake.stopApplicationMutex.Unlock()
	fake.StopApplicationStub = nil
	fake.stopApplicationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) StopApplicationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.stopApplicationMutex.Lock()
	defer fake.stopApplicationMutex.Unlock()
	fake.StopApplicationStub = nil
	if fake.stopApplicationReturnsOnCall == nil {
		fake.stopApplicationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.stopApplicationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) TerminateTask(arg1 string) (resources.Task, v7action.Warnings, error) {
	fake.terminateTaskMutex.Lock()
	ret, specificReturn := fake.terminateTaskReturnsOnCall[len(fake.terminateTaskArgsForCall)]
	fake.terminateTaskArgsForCall = append(fake.terminateTaskArgsForCall, struct {
		arg1 string
	}{arg1})
	fake.recordInvocation("TerminateTask", []interface{}{arg1})
	fake.terminateTaskMutex.Unlock()
	if fake.TerminateTaskStub != nil {
		return fake.TerminateTaskStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.terminateTaskReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) TerminateTaskCallCount() int {
	fake.terminateTaskMutex.RLock()
	defer fake.terminateTaskMutex.RUnlock()
	return len(fake.terminateTaskArgsForCall)
}

func (fake *FakeActor) TerminateTaskCalls(stub func(string) (resources.Task, v7action.Warnings, error)) {
	fake.terminateTaskMutex.Lock()
	defer fake.terminateTaskMutex.Unlock()
	fake.TerminateTaskStub = stub
}

func (fake *FakeActor) TerminateTaskArgsForCall(i int) string {
	fake.terminateTaskMutex.RLock()
	defer fake.terminateTaskMutex.RUnlock()
	argsForCall := fake.terminateTaskArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) TerminateTaskReturns(result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.terminateTaskMutex.Lock()
	defer fake.terminateTaskMutex.Unlock()
	fake.TerminateTaskStub = nil
	fake.terminateTaskReturns = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) TerminateTaskReturnsOnCall(i int, result1 resources.Task, result2 v7action.Warnings, result3 error) {
	fake.terminateTaskMutex.Lock()
	defer fake.terminateTaskMutex.Unlock()
	fake.TerminateTaskStub = nil
	if fake.terminateTaskReturnsOnCall == nil {
		fake.terminateTaskReturnsOnCall = make(map[int]struct {
			result1 resources.Task
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.terminateTaskReturnsOnCall[i] = struct {
		result1 resources.Task
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UnbindSecurityGroup(arg1 string, arg2 string, arg3 string, arg4 constanta.SecurityGroupLifecycle) (v7action.Warnings, error) {
	fake.unbindSecurityGroupMutex.Lock()
	ret, specificReturn := fake.unbindSecurityGroupReturnsOnCall[len(fake.unbindSecurityGroupArgsForCall)]
	fake.unbindSecurityGroupArgsForCall = append(fake.unbindSecurityGroupArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 constanta.SecurityGroupLifecycle
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UnbindSecurityGroup", []interface{}{arg1, arg2, arg3, arg4})
	fake.unbindSecurityGroupMutex.Unlock()
	if fake.UnbindSecurityGroupStub != nil {
		return fake.UnbindSecurityGroupStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unbindSecurityGroupReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnbindSecurityGroupCallCount() int {
	fake.unbindSecurityGroupMutex.RLock()
	defer fake.unbindSecurityGroupMutex.RUnlock()
	return len(fake.unbindSecurityGroupArgsForCall)
}

func (fake *FakeActor) UnbindSecurityGroupCalls(stub func(string, string, string, constanta.SecurityGroupLifecycle) (v7action.Warnings, error)) {
	fake.unbindSecurityGroupMutex.Lock()
	defer fake.unbindSecurityGroupMutex.Unlock()
	fake.UnbindSecurityGroupStub = stub
}

func (fake *FakeActor) UnbindSecurityGroupArgsForCall(i int) (string, string, string, constanta.SecurityGroupLifecycle) {
	fake.unbindSecurityGroupMutex.RLock()
	defer fake.unbindSecurityGroupMutex.RUnlock()
	argsForCall := fake.unbindSecurityGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UnbindSecurityGroupReturns(result1 v7action.Warnings, result2 error) {
	fake.unbindSecurityGroupMutex.Lock()
	defer fake.unbindSecurityGroupMutex.Unlock()
	fake.UnbindSecurityGroupStub = nil
	fake.unbindSecurityGroupReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnbindSecurityGroupReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unbindSecurityGroupMutex.Lock()
	defer fake.unbindSecurityGroupMutex.Unlock()
	fake.UnbindSecurityGroupStub = nil
	if fake.unbindSecurityGroupReturnsOnCall == nil {
		fake.unbindSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unbindSecurityGroupReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnmapRoute(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.unmapRouteMutex.Lock()
	ret, specificReturn := fake.unmapRouteReturnsOnCall[len(fake.unmapRouteArgsForCall)]
	fake.unmapRouteArgsForCall = append(fake.unmapRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UnmapRoute", []interface{}{arg1, arg2})
	fake.unmapRouteMutex.Unlock()
	if fake.UnmapRouteStub != nil {
		return fake.UnmapRouteStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unmapRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnmapRouteCallCount() int {
	fake.unmapRouteMutex.RLock()
	defer fake.unmapRouteMutex.RUnlock()
	return len(fake.unmapRouteArgsForCall)
}

func (fake *FakeActor) UnmapRouteCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.unmapRouteMutex.Lock()
	defer fake.unmapRouteMutex.Unlock()
	fake.UnmapRouteStub = stub
}

func (fake *FakeActor) UnmapRouteArgsForCall(i int) (string, string) {
	fake.unmapRouteMutex.RLock()
	defer fake.unmapRouteMutex.RUnlock()
	argsForCall := fake.unmapRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UnmapRouteReturns(result1 v7action.Warnings, result2 error) {
	fake.unmapRouteMutex.Lock()
	defer fake.unmapRouteMutex.Unlock()
	fake.UnmapRouteStub = nil
	fake.unmapRouteReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnmapRouteReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unmapRouteMutex.Lock()
	defer fake.unmapRouteMutex.Unlock()
	fake.UnmapRouteStub = nil
	if fake.unmapRouteReturnsOnCall == nil {
		fake.unmapRouteReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unmapRouteReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpace(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall[len(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall)]
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall = append(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("UnsetEnvironmentVariableByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	if fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub != nil {
		return fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceCallCount() int {
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RLock()
	defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock()
	return len(fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall)
}

func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub = stub
}

func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall(i int) (string, string, string) {
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RLock()
	defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock()
	argsForCall := fake.unsetEnvironmentVariableByApplicationNameAndSpaceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceReturns(result1 v7action.Warnings, result2 error) {
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub = nil
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Lock()
	defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub = nil
	if fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall == nil {
		fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnsetSpaceQuota(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.unsetSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.unsetSpaceQuotaReturnsOnCall[len(fake.unsetSpaceQuotaArgsForCall)]
	fake.unsetSpaceQuotaArgsForCall = append(fake.unsetSpaceQuotaArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("UnsetSpaceQuota", []interface{}{arg1, arg2, arg3})
	fake.unsetSpaceQuotaMutex.Unlock()
	if fake.UnsetSpaceQuotaStub != nil {
		return fake.UnsetSpaceQuotaStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unsetSpaceQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnsetSpaceQuotaCallCount() int {
	fake.unsetSpaceQuotaMutex.RLock()
	defer fake.unsetSpaceQuotaMutex.RUnlock()
	return len(fake.unsetSpaceQuotaArgsForCall)
}

func (fake *FakeActor) UnsetSpaceQuotaCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.unsetSpaceQuotaMutex.Lock()
	defer fake.unsetSpaceQuotaMutex.Unlock()
	fake.UnsetSpaceQuotaStub = stub
}

func (fake *FakeActor) UnsetSpaceQuotaArgsForCall(i int) (string, string, string) {
	fake.unsetSpaceQuotaMutex.RLock()
	defer fake.unsetSpaceQuotaMutex.RUnlock()
	argsForCall := fake.unsetSpaceQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UnsetSpaceQuotaReturns(result1 v7action.Warnings, result2 error) {
	fake.unsetSpaceQuotaMutex.Lock()
	defer fake.unsetSpaceQuotaMutex.Unlock()
	fake.UnsetSpaceQuotaStub = nil
	fake.unsetSpaceQuotaReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnsetSpaceQuotaReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unsetSpaceQuotaMutex.Lock()
	defer fake.unsetSpaceQuotaMutex.Unlock()
	fake.UnsetSpaceQuotaStub = nil
	if fake.unsetSpaceQuotaReturnsOnCall == nil {
		fake.unsetSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unsetSpaceQuotaReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnsharePrivateDomain(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.unsharePrivateDomainMutex.Lock()
	ret, specificReturn := fake.unsharePrivateDomainReturnsOnCall[len(fake.unsharePrivateDomainArgsForCall)]
	fake.unsharePrivateDomainArgsForCall = append(fake.unsharePrivateDomainArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UnsharePrivateDomain", []interface{}{arg1, arg2})
	fake.unsharePrivateDomainMutex.Unlock()
	if fake.UnsharePrivateDomainStub != nil {
		return fake.UnsharePrivateDomainStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unsharePrivateDomainReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnsharePrivateDomainCallCount() int {
	fake.unsharePrivateDomainMutex.RLock()
	defer fake.unsharePrivateDomainMutex.RUnlock()
	return len(fake.unsharePrivateDomainArgsForCall)
}

func (fake *FakeActor) UnsharePrivateDomainCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.unsharePrivateDomainMutex.Lock()
	defer fake.unsharePrivateDomainMutex.Unlock()
	fake.UnsharePrivateDomainStub = stub
}

func (fake *FakeActor) UnsharePrivateDomainArgsForCall(i int) (string, string) {
	fake.unsharePrivateDomainMutex.RLock()
	defer fake.unsharePrivateDomainMutex.RUnlock()
	argsForCall := fake.unsharePrivateDomainArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UnsharePrivateDomainReturns(result1 v7action.Warnings, result2 error) {
	fake.unsharePrivateDomainMutex.Lock()
	defer fake.unsharePrivateDomainMutex.Unlock()
	fake.UnsharePrivateDomainStub = nil
	fake.unsharePrivateDomainReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnsharePrivateDomainReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unsharePrivateDomainMutex.Lock()
	defer fake.unsharePrivateDomainMutex.Unlock()
	fake.UnsharePrivateDomainStub = nil
	if fake.unsharePrivateDomainReturnsOnCall == nil {
		fake.unsharePrivateDomainReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unsharePrivateDomainReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnshareRoute(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.unshareRouteMutex.Lock()
	ret, specificReturn := fake.unshareRouteReturnsOnCall[len(fake.unshareRouteArgsForCall)]
	fake.unshareRouteArgsForCall = append(fake.unshareRouteArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UnshareRoute", []interface{}{arg1, arg2})
	fake.unshareRouteMutex.Unlock()
	if fake.UnshareRouteStub != nil {
		return fake.UnshareRouteStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unshareRouteReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnshareRouteCallCount() int {
	fake.unshareRouteMutex.RLock()
	defer fake.unshareRouteMutex.RUnlock()
	return len(fake.unshareRouteArgsForCall)
}

func (fake *FakeActor) UnshareRouteCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.unshareRouteMutex.Lock()
	defer fake.unshareRouteMutex.Unlock()
	fake.UnshareRouteStub = stub
}

func (fake *FakeActor) UnshareRouteArgsForCall(i int) (string, string) {
	fake.unshareRouteMutex.RLock()
	defer fake.unshareRouteMutex.RUnlock()
	argsForCall := fake.unshareRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UnshareRouteReturns(result1 v7action.Warnings, result2 error) {
	fake.unshareRouteMutex.Lock()
	defer fake.unshareRouteMutex.Unlock()
	fake.UnshareRouteStub = nil
	fake.unshareRouteReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnshareRouteReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unshareRouteMutex.Lock()
	defer fake.unshareRouteMutex.Unlock()
	fake.UnshareRouteStub = nil
	if fake.unshareRouteReturnsOnCall == nil {
		fake.unshareRouteReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unshareRouteReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrg(arg1 string, arg2 string, arg3 string, arg4 v7action.ServiceInstanceSharingParams) (v7action.Warnings, error) {
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.Lock()
	ret, specificReturn := fake.unshareServiceInstanceFromSpaceAndOrgReturnsOnCall[len(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall)]
	fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall = append(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 v7action.ServiceInstanceSharingParams
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UnshareServiceInstanceFromSpaceAndOrg", []interface{}{arg1, arg2, arg3, arg4})
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.Unlock()
	if fake.UnshareServiceInstanceFromSpaceAndOrgStub != nil {
		return fake.UnshareServiceInstanceFromSpaceAndOrgStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.unshareServiceInstanceFromSpaceAndOrgReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgCallCount() int {
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.RUnlock()
	return len(fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall)
}

func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgCalls(stub func(string, string, string, v7action.ServiceInstanceSharingParams) (v7action.Warnings, error)) {
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.Lock()
	defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.Unlock()
	fake.UnshareServiceInstanceFromSpaceAndOrgStub = stub
}

func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgArgsForCall(i int) (string, string, string, v7action.ServiceInstanceSharingParams) {
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.RUnlock()
	argsForCall := fake.unshareServiceInstanceFromSpaceAndOrgArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgReturns(result1 v7action.Warnings, result2 error) {
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.Lock()
	defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.Unlock()
	fake.UnshareServiceInstanceFromSpaceAndOrgStub = nil
	fake.unshareServiceInstanceFromSpaceAndOrgReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UnshareServiceInstanceFromSpaceAndOrgReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.Lock()
	defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.Unlock()
	fake.UnshareServiceInstanceFromSpaceAndOrgStub = nil
	if fake.unshareServiceInstanceFromSpaceAndOrgReturnsOnCall == nil {
		fake.unshareServiceInstanceFromSpaceAndOrgReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.unshareServiceInstanceFromSpaceAndOrgReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateAppFeature(arg1 resources.Application, arg2 bool, arg3 string) (v7action.Warnings, error) {
	fake.updateAppFeatureMutex.Lock()
	ret, specificReturn := fake.updateAppFeatureReturnsOnCall[len(fake.updateAppFeatureArgsForCall)]
	fake.updateAppFeatureArgsForCall = append(fake.updateAppFeatureArgsForCall, struct {
		arg1 resources.Application
		arg2 bool
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateAppFeature", []interface{}{arg1, arg2, arg3})
	fake.updateAppFeatureMutex.Unlock()
	if fake.UpdateAppFeatureStub != nil {
		return fake.UpdateAppFeatureStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateAppFeatureReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateAppFeatureCallCount() int {
	fake.updateAppFeatureMutex.RLock()
	defer fake.updateAppFeatureMutex.RUnlock()
	return len(fake.updateAppFeatureArgsForCall)
}

func (fake *FakeActor) UpdateAppFeatureCalls(stub func(resources.Application, bool, string) (v7action.Warnings, error)) {
	fake.updateAppFeatureMutex.Lock()
	defer fake.updateAppFeatureMutex.Unlock()
	fake.UpdateAppFeatureStub = stub
}

func (fake *FakeActor) UpdateAppFeatureArgsForCall(i int) (resources.Application, bool, string) {
	fake.updateAppFeatureMutex.RLock()
	defer fake.updateAppFeatureMutex.RUnlock()
	argsForCall := fake.updateAppFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateAppFeatureReturns(result1 v7action.Warnings, result2 error) {
	fake.updateAppFeatureMutex.Lock()
	defer fake.updateAppFeatureMutex.Unlock()
	fake.UpdateAppFeatureStub = nil
	fake.updateAppFeatureReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateAppFeatureReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateAppFeatureMutex.Lock()
	defer fake.updateAppFeatureMutex.Unlock()
	fake.UpdateAppFeatureStub = nil
	if fake.updateAppFeatureReturnsOnCall == nil {
		fake.updateAppFeatureReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateAppFeatureReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateApplication(arg1 resources.Application) (resources.Application, v7action.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 *FakeActor) UpdateApplicationCallCount() int {
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	return len(fake.updateApplicationArgsForCall)
}

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

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

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

func (fake *FakeActor) UpdateApplicationReturnsOnCall(i int, result1 resources.Application, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.updateApplicationReturnsOnCall[i] = struct {
		result1 resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateApplicationLabelsByApplicationName(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateApplicationLabelsByApplicationNameMutex.Lock()
	ret, specificReturn := fake.updateApplicationLabelsByApplicationNameReturnsOnCall[len(fake.updateApplicationLabelsByApplicationNameArgsForCall)]
	fake.updateApplicationLabelsByApplicationNameArgsForCall = append(fake.updateApplicationLabelsByApplicationNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateApplicationLabelsByApplicationName", []interface{}{arg1, arg2, arg3})
	fake.updateApplicationLabelsByApplicationNameMutex.Unlock()
	if fake.UpdateApplicationLabelsByApplicationNameStub != nil {
		return fake.UpdateApplicationLabelsByApplicationNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateApplicationLabelsByApplicationNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameCallCount() int {
	fake.updateApplicationLabelsByApplicationNameMutex.RLock()
	defer fake.updateApplicationLabelsByApplicationNameMutex.RUnlock()
	return len(fake.updateApplicationLabelsByApplicationNameArgsForCall)
}

func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameCalls(stub func(string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateApplicationLabelsByApplicationNameMutex.Lock()
	defer fake.updateApplicationLabelsByApplicationNameMutex.Unlock()
	fake.UpdateApplicationLabelsByApplicationNameStub = stub
}

func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameArgsForCall(i int) (string, string, map[string]types.NullString) {
	fake.updateApplicationLabelsByApplicationNameMutex.RLock()
	defer fake.updateApplicationLabelsByApplicationNameMutex.RUnlock()
	argsForCall := fake.updateApplicationLabelsByApplicationNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameReturns(result1 v7action.Warnings, result2 error) {
	fake.updateApplicationLabelsByApplicationNameMutex.Lock()
	defer fake.updateApplicationLabelsByApplicationNameMutex.Unlock()
	fake.UpdateApplicationLabelsByApplicationNameStub = nil
	fake.updateApplicationLabelsByApplicationNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateApplicationLabelsByApplicationNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateApplicationLabelsByApplicationNameMutex.Lock()
	defer fake.updateApplicationLabelsByApplicationNameMutex.Unlock()
	fake.UpdateApplicationLabelsByApplicationNameStub = nil
	if fake.updateApplicationLabelsByApplicationNameReturnsOnCall == nil {
		fake.updateApplicationLabelsByApplicationNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateApplicationLabelsByApplicationNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateBuildpackByNameAndStack(arg1 string, arg2 string, arg3 resources.Buildpack) (resources.Buildpack, v7action.Warnings, error) {
	fake.updateBuildpackByNameAndStackMutex.Lock()
	ret, specificReturn := fake.updateBuildpackByNameAndStackReturnsOnCall[len(fake.updateBuildpackByNameAndStackArgsForCall)]
	fake.updateBuildpackByNameAndStackArgsForCall = append(fake.updateBuildpackByNameAndStackArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 resources.Buildpack
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateBuildpackByNameAndStack", []interface{}{arg1, arg2, arg3})
	fake.updateBuildpackByNameAndStackMutex.Unlock()
	if fake.UpdateBuildpackByNameAndStackStub != nil {
		return fake.UpdateBuildpackByNameAndStackStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateBuildpackByNameAndStackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackCallCount() int {
	fake.updateBuildpackByNameAndStackMutex.RLock()
	defer fake.updateBuildpackByNameAndStackMutex.RUnlock()
	return len(fake.updateBuildpackByNameAndStackArgsForCall)
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackCalls(stub func(string, string, resources.Buildpack) (resources.Buildpack, v7action.Warnings, error)) {
	fake.updateBuildpackByNameAndStackMutex.Lock()
	defer fake.updateBuildpackByNameAndStackMutex.Unlock()
	fake.UpdateBuildpackByNameAndStackStub = stub
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackArgsForCall(i int) (string, string, resources.Buildpack) {
	fake.updateBuildpackByNameAndStackMutex.RLock()
	defer fake.updateBuildpackByNameAndStackMutex.RUnlock()
	argsForCall := fake.updateBuildpackByNameAndStackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackReturns(result1 resources.Buildpack, result2 v7action.Warnings, result3 error) {
	fake.updateBuildpackByNameAndStackMutex.Lock()
	defer fake.updateBuildpackByNameAndStackMutex.Unlock()
	fake.UpdateBuildpackByNameAndStackStub = nil
	fake.updateBuildpackByNameAndStackReturns = struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackReturnsOnCall(i int, result1 resources.Buildpack, result2 v7action.Warnings, result3 error) {
	fake.updateBuildpackByNameAndStackMutex.Lock()
	defer fake.updateBuildpackByNameAndStackMutex.Unlock()
	fake.UpdateBuildpackByNameAndStackStub = nil
	if fake.updateBuildpackByNameAndStackReturnsOnCall == nil {
		fake.updateBuildpackByNameAndStackReturnsOnCall = make(map[int]struct {
			result1 resources.Buildpack
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.updateBuildpackByNameAndStackReturnsOnCall[i] = struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStack(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Lock()
	ret, specificReturn := fake.updateBuildpackLabelsByBuildpackNameAndStackReturnsOnCall[len(fake.updateBuildpackLabelsByBuildpackNameAndStackArgsForCall)]
	fake.updateBuildpackLabelsByBuildpackNameAndStackArgsForCall = append(fake.updateBuildpackLabelsByBuildpackNameAndStackArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateBuildpackLabelsByBuildpackNameAndStack", []interface{}{arg1, arg2, arg3})
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Unlock()
	if fake.UpdateBuildpackLabelsByBuildpackNameAndStackStub != nil {
		return fake.UpdateBuildpackLabelsByBuildpackNameAndStackStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateBuildpackLabelsByBuildpackNameAndStackReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackCallCount() int {
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.RLock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.RUnlock()
	return len(fake.updateBuildpackLabelsByBuildpackNameAndStackArgsForCall)
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackCalls(stub func(string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Lock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Unlock()
	fake.UpdateBuildpackLabelsByBuildpackNameAndStackStub = stub
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackArgsForCall(i int) (string, string, map[string]types.NullString) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.RLock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.RUnlock()
	argsForCall := fake.updateBuildpackLabelsByBuildpackNameAndStackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackReturns(result1 v7action.Warnings, result2 error) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Lock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Unlock()
	fake.UpdateBuildpackLabelsByBuildpackNameAndStackStub = nil
	fake.updateBuildpackLabelsByBuildpackNameAndStackReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Lock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.Unlock()
	fake.UpdateBuildpackLabelsByBuildpackNameAndStackStub = nil
	if fake.updateBuildpackLabelsByBuildpackNameAndStackReturnsOnCall == nil {
		fake.updateBuildpackLabelsByBuildpackNameAndStackReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateBuildpackLabelsByBuildpackNameAndStackReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateDestination(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.updateDestinationMutex.Lock()
	ret, specificReturn := fake.updateDestinationReturnsOnCall[len(fake.updateDestinationArgsForCall)]
	fake.updateDestinationArgsForCall = append(fake.updateDestinationArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateDestination", []interface{}{arg1, arg2, arg3})
	fake.updateDestinationMutex.Unlock()
	if fake.UpdateDestinationStub != nil {
		return fake.UpdateDestinationStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateDestinationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateDestinationCallCount() int {
	fake.updateDestinationMutex.RLock()
	defer fake.updateDestinationMutex.RUnlock()
	return len(fake.updateDestinationArgsForCall)
}

func (fake *FakeActor) UpdateDestinationCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.updateDestinationMutex.Lock()
	defer fake.updateDestinationMutex.Unlock()
	fake.UpdateDestinationStub = stub
}

func (fake *FakeActor) UpdateDestinationArgsForCall(i int) (string, string, string) {
	fake.updateDestinationMutex.RLock()
	defer fake.updateDestinationMutex.RUnlock()
	argsForCall := fake.updateDestinationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateDestinationReturns(result1 v7action.Warnings, result2 error) {
	fake.updateDestinationMutex.Lock()
	defer fake.updateDestinationMutex.Unlock()
	fake.UpdateDestinationStub = nil
	fake.updateDestinationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateDestinationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateDestinationMutex.Lock()
	defer fake.updateDestinationMutex.Unlock()
	fake.UpdateDestinationStub = nil
	if fake.updateDestinationReturnsOnCall == nil {
		fake.updateDestinationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateDestinationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateDomainLabelsByDomainName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateDomainLabelsByDomainNameMutex.Lock()
	ret, specificReturn := fake.updateDomainLabelsByDomainNameReturnsOnCall[len(fake.updateDomainLabelsByDomainNameArgsForCall)]
	fake.updateDomainLabelsByDomainNameArgsForCall = append(fake.updateDomainLabelsByDomainNameArgsForCall, struct {
		arg1 string
		arg2 map[string]types.NullString
	}{arg1, arg2})
	fake.recordInvocation("UpdateDomainLabelsByDomainName", []interface{}{arg1, arg2})
	fake.updateDomainLabelsByDomainNameMutex.Unlock()
	if fake.UpdateDomainLabelsByDomainNameStub != nil {
		return fake.UpdateDomainLabelsByDomainNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateDomainLabelsByDomainNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateDomainLabelsByDomainNameCallCount() int {
	fake.updateDomainLabelsByDomainNameMutex.RLock()
	defer fake.updateDomainLabelsByDomainNameMutex.RUnlock()
	return len(fake.updateDomainLabelsByDomainNameArgsForCall)
}

func (fake *FakeActor) UpdateDomainLabelsByDomainNameCalls(stub func(string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateDomainLabelsByDomainNameMutex.Lock()
	defer fake.updateDomainLabelsByDomainNameMutex.Unlock()
	fake.UpdateDomainLabelsByDomainNameStub = stub
}

func (fake *FakeActor) UpdateDomainLabelsByDomainNameArgsForCall(i int) (string, map[string]types.NullString) {
	fake.updateDomainLabelsByDomainNameMutex.RLock()
	defer fake.updateDomainLabelsByDomainNameMutex.RUnlock()
	argsForCall := fake.updateDomainLabelsByDomainNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateDomainLabelsByDomainNameReturns(result1 v7action.Warnings, result2 error) {
	fake.updateDomainLabelsByDomainNameMutex.Lock()
	defer fake.updateDomainLabelsByDomainNameMutex.Unlock()
	fake.UpdateDomainLabelsByDomainNameStub = nil
	fake.updateDomainLabelsByDomainNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateDomainLabelsByDomainNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateDomainLabelsByDomainNameMutex.Lock()
	defer fake.updateDomainLabelsByDomainNameMutex.Unlock()
	fake.UpdateDomainLabelsByDomainNameStub = nil
	if fake.updateDomainLabelsByDomainNameReturnsOnCall == nil {
		fake.updateDomainLabelsByDomainNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateDomainLabelsByDomainNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateManagedServiceInstance(arg1 v7action.UpdateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.updateManagedServiceInstanceMutex.Lock()
	ret, specificReturn := fake.updateManagedServiceInstanceReturnsOnCall[len(fake.updateManagedServiceInstanceArgsForCall)]
	fake.updateManagedServiceInstanceArgsForCall = append(fake.updateManagedServiceInstanceArgsForCall, struct {
		arg1 v7action.UpdateManagedServiceInstanceParams
	}{arg1})
	fake.recordInvocation("UpdateManagedServiceInstance", []interface{}{arg1})
	fake.updateManagedServiceInstanceMutex.Unlock()
	if fake.UpdateManagedServiceInstanceStub != nil {
		return fake.UpdateManagedServiceInstanceStub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.updateManagedServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) UpdateManagedServiceInstanceCallCount() int {
	fake.updateManagedServiceInstanceMutex.RLock()
	defer fake.updateManagedServiceInstanceMutex.RUnlock()
	return len(fake.updateManagedServiceInstanceArgsForCall)
}

func (fake *FakeActor) UpdateManagedServiceInstanceCalls(stub func(v7action.UpdateManagedServiceInstanceParams) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.updateManagedServiceInstanceMutex.Lock()
	defer fake.updateManagedServiceInstanceMutex.Unlock()
	fake.UpdateManagedServiceInstanceStub = stub
}

func (fake *FakeActor) UpdateManagedServiceInstanceArgsForCall(i int) v7action.UpdateManagedServiceInstanceParams {
	fake.updateManagedServiceInstanceMutex.RLock()
	defer fake.updateManagedServiceInstanceMutex.RUnlock()
	argsForCall := fake.updateManagedServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) UpdateManagedServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.updateManagedServiceInstanceMutex.Lock()
	defer fake.updateManagedServiceInstanceMutex.Unlock()
	fake.UpdateManagedServiceInstanceStub = nil
	fake.updateManagedServiceInstanceReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateManagedServiceInstanceReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.updateManagedServiceInstanceMutex.Lock()
	defer fake.updateManagedServiceInstanceMutex.Unlock()
	fake.UpdateManagedServiceInstanceStub = nil
	if fake.updateManagedServiceInstanceReturnsOnCall == nil {
		fake.updateManagedServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.updateManagedServiceInstanceReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateOrganizationLabelsByOrganizationNameMutex.Lock()
	ret, specificReturn := fake.updateOrganizationLabelsByOrganizationNameReturnsOnCall[len(fake.updateOrganizationLabelsByOrganizationNameArgsForCall)]
	fake.updateOrganizationLabelsByOrganizationNameArgsForCall = append(fake.updateOrganizationLabelsByOrganizationNameArgsForCall, struct {
		arg1 string
		arg2 map[string]types.NullString
	}{arg1, arg2})
	fake.recordInvocation("UpdateOrganizationLabelsByOrganizationName", []interface{}{arg1, arg2})
	fake.updateOrganizationLabelsByOrganizationNameMutex.Unlock()
	if fake.UpdateOrganizationLabelsByOrganizationNameStub != nil {
		return fake.UpdateOrganizationLabelsByOrganizationNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrganizationLabelsByOrganizationNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameCallCount() int {
	fake.updateOrganizationLabelsByOrganizationNameMutex.RLock()
	defer fake.updateOrganizationLabelsByOrganizationNameMutex.RUnlock()
	return len(fake.updateOrganizationLabelsByOrganizationNameArgsForCall)
}

func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameCalls(stub func(string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateOrganizationLabelsByOrganizationNameMutex.Lock()
	defer fake.updateOrganizationLabelsByOrganizationNameMutex.Unlock()
	fake.UpdateOrganizationLabelsByOrganizationNameStub = stub
}

func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameArgsForCall(i int) (string, map[string]types.NullString) {
	fake.updateOrganizationLabelsByOrganizationNameMutex.RLock()
	defer fake.updateOrganizationLabelsByOrganizationNameMutex.RUnlock()
	argsForCall := fake.updateOrganizationLabelsByOrganizationNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameReturns(result1 v7action.Warnings, result2 error) {
	fake.updateOrganizationLabelsByOrganizationNameMutex.Lock()
	defer fake.updateOrganizationLabelsByOrganizationNameMutex.Unlock()
	fake.UpdateOrganizationLabelsByOrganizationNameStub = nil
	fake.updateOrganizationLabelsByOrganizationNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateOrganizationLabelsByOrganizationNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateOrganizationLabelsByOrganizationNameMutex.Lock()
	defer fake.updateOrganizationLabelsByOrganizationNameMutex.Unlock()
	fake.UpdateOrganizationLabelsByOrganizationNameStub = nil
	if fake.updateOrganizationLabelsByOrganizationNameReturnsOnCall == nil {
		fake.updateOrganizationLabelsByOrganizationNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateOrganizationLabelsByOrganizationNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateOrganizationQuota(arg1 string, arg2 string, arg3 v7action.QuotaLimits) (v7action.Warnings, error) {
	fake.updateOrganizationQuotaMutex.Lock()
	ret, specificReturn := fake.updateOrganizationQuotaReturnsOnCall[len(fake.updateOrganizationQuotaArgsForCall)]
	fake.updateOrganizationQuotaArgsForCall = append(fake.updateOrganizationQuotaArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 v7action.QuotaLimits
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateOrganizationQuota", []interface{}{arg1, arg2, arg3})
	fake.updateOrganizationQuotaMutex.Unlock()
	if fake.UpdateOrganizationQuotaStub != nil {
		return fake.UpdateOrganizationQuotaStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateOrganizationQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateOrganizationQuotaCallCount() int {
	fake.updateOrganizationQuotaMutex.RLock()
	defer fake.updateOrganizationQuotaMutex.RUnlock()
	return len(fake.updateOrganizationQuotaArgsForCall)
}

func (fake *FakeActor) UpdateOrganizationQuotaCalls(stub func(string, string, v7action.QuotaLimits) (v7action.Warnings, error)) {
	fake.updateOrganizationQuotaMutex.Lock()
	defer fake.updateOrganizationQuotaMutex.Unlock()
	fake.UpdateOrganizationQuotaStub = stub
}

func (fake *FakeActor) UpdateOrganizationQuotaArgsForCall(i int) (string, string, v7action.QuotaLimits) {
	fake.updateOrganizationQuotaMutex.RLock()
	defer fake.updateOrganizationQuotaMutex.RUnlock()
	argsForCall := fake.updateOrganizationQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateOrganizationQuotaReturns(result1 v7action.Warnings, result2 error) {
	fake.updateOrganizationQuotaMutex.Lock()
	defer fake.updateOrganizationQuotaMutex.Unlock()
	fake.UpdateOrganizationQuotaStub = nil
	fake.updateOrganizationQuotaReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateOrganizationQuotaReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateOrganizationQuotaMutex.Lock()
	defer fake.updateOrganizationQuotaMutex.Unlock()
	fake.UpdateOrganizationQuotaStub = nil
	if fake.updateOrganizationQuotaReturnsOnCall == nil {
		fake.updateOrganizationQuotaReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateOrganizationQuotaReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateProcessByTypeAndApplication(arg1 string, arg2 string, arg3 resources.Process) (v7action.Warnings, error) {
	fake.updateProcessByTypeAndApplicationMutex.Lock()
	ret, specificReturn := fake.updateProcessByTypeAndApplicationReturnsOnCall[len(fake.updateProcessByTypeAndApplicationArgsForCall)]
	fake.updateProcessByTypeAndApplicationArgsForCall = append(fake.updateProcessByTypeAndApplicationArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 resources.Process
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateProcessByTypeAndApplication", []interface{}{arg1, arg2, arg3})
	fake.updateProcessByTypeAndApplicationMutex.Unlock()
	if fake.UpdateProcessByTypeAndApplicationStub != nil {
		return fake.UpdateProcessByTypeAndApplicationStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateProcessByTypeAndApplicationReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateProcessByTypeAndApplicationCallCount() int {
	fake.updateProcessByTypeAndApplicationMutex.RLock()
	defer fake.updateProcessByTypeAndApplicationMutex.RUnlock()
	return len(fake.updateProcessByTypeAndApplicationArgsForCall)
}

func (fake *FakeActor) UpdateProcessByTypeAndApplicationCalls(stub func(string, string, resources.Process) (v7action.Warnings, error)) {
	fake.updateProcessByTypeAndApplicationMutex.Lock()
	defer fake.updateProcessByTypeAndApplicationMutex.Unlock()
	fake.UpdateProcessByTypeAndApplicationStub = stub
}

func (fake *FakeActor) UpdateProcessByTypeAndApplicationArgsForCall(i int) (string, string, resources.Process) {
	fake.updateProcessByTypeAndApplicationMutex.RLock()
	defer fake.updateProcessByTypeAndApplicationMutex.RUnlock()
	argsForCall := fake.updateProcessByTypeAndApplicationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateProcessByTypeAndApplicationReturns(result1 v7action.Warnings, result2 error) {
	fake.updateProcessByTypeAndApplicationMutex.Lock()
	defer fake.updateProcessByTypeAndApplicationMutex.Unlock()
	fake.UpdateProcessByTypeAndApplicationStub = nil
	fake.updateProcessByTypeAndApplicationReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateProcessByTypeAndApplicationReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateProcessByTypeAndApplicationMutex.Lock()
	defer fake.updateProcessByTypeAndApplicationMutex.Unlock()
	fake.UpdateProcessByTypeAndApplicationStub = nil
	if fake.updateProcessByTypeAndApplicationReturnsOnCall == nil {
		fake.updateProcessByTypeAndApplicationReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateProcessByTypeAndApplicationReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateRouteLabels(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateRouteLabelsMutex.Lock()
	ret, specificReturn := fake.updateRouteLabelsReturnsOnCall[len(fake.updateRouteLabelsArgsForCall)]
	fake.updateRouteLabelsArgsForCall = append(fake.updateRouteLabelsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateRouteLabels", []interface{}{arg1, arg2, arg3})
	fake.updateRouteLabelsMutex.Unlock()
	if fake.UpdateRouteLabelsStub != nil {
		return fake.UpdateRouteLabelsStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateRouteLabelsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateRouteLabelsCallCount() int {
	fake.updateRouteLabelsMutex.RLock()
	defer fake.updateRouteLabelsMutex.RUnlock()
	return len(fake.updateRouteLabelsArgsForCall)
}

func (fake *FakeActor) UpdateRouteLabelsCalls(stub func(string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateRouteLabelsMutex.Lock()
	defer fake.updateRouteLabelsMutex.Unlock()
	fake.UpdateRouteLabelsStub = stub
}

func (fake *FakeActor) UpdateRouteLabelsArgsForCall(i int) (string, string, map[string]types.NullString) {
	fake.updateRouteLabelsMutex.RLock()
	defer fake.updateRouteLabelsMutex.RUnlock()
	argsForCall := fake.updateRouteLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateRouteLabelsReturns(result1 v7action.Warnings, result2 error) {
	fake.updateRouteLabelsMutex.Lock()
	defer fake.updateRouteLabelsMutex.Unlock()
	fake.UpdateRouteLabelsStub = nil
	fake.updateRouteLabelsReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateRouteLabelsReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateRouteLabelsMutex.Lock()
	defer fake.updateRouteLabelsMutex.Unlock()
	fake.UpdateRouteLabelsStub = nil
	if fake.updateRouteLabelsReturnsOnCall == nil {
		fake.updateRouteLabelsReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateRouteLabelsReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSecurityGroup(arg1 string, arg2 string) (v7action.Warnings, error) {
	fake.updateSecurityGroupMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupReturnsOnCall[len(fake.updateSecurityGroupArgsForCall)]
	fake.updateSecurityGroupArgsForCall = append(fake.updateSecurityGroupArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpdateSecurityGroup", []interface{}{arg1, arg2})
	fake.updateSecurityGroupMutex.Unlock()
	if fake.UpdateSecurityGroupStub != nil {
		return fake.UpdateSecurityGroupStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSecurityGroupReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateSecurityGroupCallCount() int {
	fake.updateSecurityGroupMutex.RLock()
	defer fake.updateSecurityGroupMutex.RUnlock()
	return len(fake.updateSecurityGroupArgsForCall)
}

func (fake *FakeActor) UpdateSecurityGroupCalls(stub func(string, string) (v7action.Warnings, error)) {
	fake.updateSecurityGroupMutex.Lock()
	defer fake.updateSecurityGroupMutex.Unlock()
	fake.UpdateSecurityGroupStub = stub
}

func (fake *FakeActor) UpdateSecurityGroupArgsForCall(i int) (string, string) {
	fake.updateSecurityGroupMutex.RLock()
	defer fake.updateSecurityGroupMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateSecurityGroupReturns(result1 v7action.Warnings, result2 error) {
	fake.updateSecurityGroupMutex.Lock()
	defer fake.updateSecurityGroupMutex.Unlock()
	fake.UpdateSecurityGroupStub = nil
	fake.updateSecurityGroupReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSecurityGroupReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateSecurityGroupMutex.Lock()
	defer fake.updateSecurityGroupMutex.Unlock()
	fake.UpdateSecurityGroupStub = nil
	if fake.updateSecurityGroupReturnsOnCall == nil {
		fake.updateSecurityGroupReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateSecurityGroupReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSecurityGroupGloballyEnabled(arg1 string, arg2 constanta.SecurityGroupLifecycle, arg3 bool) (v7action.Warnings, error) {
	fake.updateSecurityGroupGloballyEnabledMutex.Lock()
	ret, specificReturn := fake.updateSecurityGroupGloballyEnabledReturnsOnCall[len(fake.updateSecurityGroupGloballyEnabledArgsForCall)]
	fake.updateSecurityGroupGloballyEnabledArgsForCall = append(fake.updateSecurityGroupGloballyEnabledArgsForCall, struct {
		arg1 string
		arg2 constanta.SecurityGroupLifecycle
		arg3 bool
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateSecurityGroupGloballyEnabled", []interface{}{arg1, arg2, arg3})
	fake.updateSecurityGroupGloballyEnabledMutex.Unlock()
	if fake.UpdateSecurityGroupGloballyEnabledStub != nil {
		return fake.UpdateSecurityGroupGloballyEnabledStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSecurityGroupGloballyEnabledReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledCallCount() int {
	fake.updateSecurityGroupGloballyEnabledMutex.RLock()
	defer fake.updateSecurityGroupGloballyEnabledMutex.RUnlock()
	return len(fake.updateSecurityGroupGloballyEnabledArgsForCall)
}

func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledCalls(stub func(string, constanta.SecurityGroupLifecycle, bool) (v7action.Warnings, error)) {
	fake.updateSecurityGroupGloballyEnabledMutex.Lock()
	defer fake.updateSecurityGroupGloballyEnabledMutex.Unlock()
	fake.UpdateSecurityGroupGloballyEnabledStub = stub
}

func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledArgsForCall(i int) (string, constanta.SecurityGroupLifecycle, bool) {
	fake.updateSecurityGroupGloballyEnabledMutex.RLock()
	defer fake.updateSecurityGroupGloballyEnabledMutex.RUnlock()
	argsForCall := fake.updateSecurityGroupGloballyEnabledArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledReturns(result1 v7action.Warnings, result2 error) {
	fake.updateSecurityGroupGloballyEnabledMutex.Lock()
	defer fake.updateSecurityGroupGloballyEnabledMutex.Unlock()
	fake.UpdateSecurityGroupGloballyEnabledStub = nil
	fake.updateSecurityGroupGloballyEnabledReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSecurityGroupGloballyEnabledReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateSecurityGroupGloballyEnabledMutex.Lock()
	defer fake.updateSecurityGroupGloballyEnabledMutex.Unlock()
	fake.UpdateSecurityGroupGloballyEnabledStub = nil
	if fake.updateSecurityGroupGloballyEnabledReturnsOnCall == nil {
		fake.updateSecurityGroupGloballyEnabledReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateSecurityGroupGloballyEnabledReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceBroker(arg1 string, arg2 resources.ServiceBroker) (v7action.Warnings, error) {
	fake.updateServiceBrokerMutex.Lock()
	ret, specificReturn := fake.updateServiceBrokerReturnsOnCall[len(fake.updateServiceBrokerArgsForCall)]
	fake.updateServiceBrokerArgsForCall = append(fake.updateServiceBrokerArgsForCall, struct {
		arg1 string
		arg2 resources.ServiceBroker
	}{arg1, arg2})
	fake.recordInvocation("UpdateServiceBroker", []interface{}{arg1, arg2})
	fake.updateServiceBrokerMutex.Unlock()
	if fake.UpdateServiceBrokerStub != nil {
		return fake.UpdateServiceBrokerStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateServiceBrokerReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateServiceBrokerCallCount() int {
	fake.updateServiceBrokerMutex.RLock()
	defer fake.updateServiceBrokerMutex.RUnlock()
	return len(fake.updateServiceBrokerArgsForCall)
}

func (fake *FakeActor) UpdateServiceBrokerCalls(stub func(string, resources.ServiceBroker) (v7action.Warnings, error)) {
	fake.updateServiceBrokerMutex.Lock()
	defer fake.updateServiceBrokerMutex.Unlock()
	fake.UpdateServiceBrokerStub = stub
}

func (fake *FakeActor) UpdateServiceBrokerArgsForCall(i int) (string, resources.ServiceBroker) {
	fake.updateServiceBrokerMutex.RLock()
	defer fake.updateServiceBrokerMutex.RUnlock()
	argsForCall := fake.updateServiceBrokerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateServiceBrokerReturns(result1 v7action.Warnings, result2 error) {
	fake.updateServiceBrokerMutex.Lock()
	defer fake.updateServiceBrokerMutex.Unlock()
	fake.UpdateServiceBrokerStub = nil
	fake.updateServiceBrokerReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceBrokerReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateServiceBrokerMutex.Lock()
	defer fake.updateServiceBrokerMutex.Unlock()
	fake.UpdateServiceBrokerStub = nil
	if fake.updateServiceBrokerReturnsOnCall == nil {
		fake.updateServiceBrokerReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateServiceBrokerReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Lock()
	ret, specificReturn := fake.updateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall[len(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall)]
	fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall = append(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall, struct {
		arg1 string
		arg2 map[string]types.NullString
	}{arg1, arg2})
	fake.recordInvocation("UpdateServiceBrokerLabelsByServiceBrokerName", []interface{}{arg1, arg2})
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Unlock()
	if fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub != nil {
		return fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateServiceBrokerLabelsByServiceBrokerNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameCallCount() int {
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RLock()
	defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RUnlock()
	return len(fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall)
}

func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameCalls(stub func(string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Lock()
	defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Unlock()
	fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub = stub
}

func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameArgsForCall(i int) (string, map[string]types.NullString) {
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RLock()
	defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RUnlock()
	argsForCall := fake.updateServiceBrokerLabelsByServiceBrokerNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameReturns(result1 v7action.Warnings, result2 error) {
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Lock()
	defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Unlock()
	fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub = nil
	fake.updateServiceBrokerLabelsByServiceBrokerNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Lock()
	defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Unlock()
	fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub = nil
	if fake.updateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall == nil {
		fake.updateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateServiceBrokerLabelsByServiceBrokerNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceInstanceLabels(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateServiceInstanceLabelsMutex.Lock()
	ret, specificReturn := fake.updateServiceInstanceLabelsReturnsOnCall[len(fake.updateServiceInstanceLabelsArgsForCall)]
	fake.updateServiceInstanceLabelsArgsForCall = append(fake.updateServiceInstanceLabelsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateServiceInstanceLabels", []interface{}{arg1, arg2, arg3})
	fake.updateServiceInstanceLabelsMutex.Unlock()
	if fake.UpdateServiceInstanceLabelsStub != nil {
		return fake.UpdateServiceInstanceLabelsStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateServiceInstanceLabelsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateServiceInstanceLabelsCallCount() int {
	fake.updateServiceInstanceLabelsMutex.RLock()
	defer fake.updateServiceInstanceLabelsMutex.RUnlock()
	return len(fake.updateServiceInstanceLabelsArgsForCall)
}

func (fake *FakeActor) UpdateServiceInstanceLabelsCalls(stub func(string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateServiceInstanceLabelsMutex.Lock()
	defer fake.updateServiceInstanceLabelsMutex.Unlock()
	fake.UpdateServiceInstanceLabelsStub = stub
}

func (fake *FakeActor) UpdateServiceInstanceLabelsArgsForCall(i int) (string, string, map[string]types.NullString) {
	fake.updateServiceInstanceLabelsMutex.RLock()
	defer fake.updateServiceInstanceLabelsMutex.RUnlock()
	argsForCall := fake.updateServiceInstanceLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateServiceInstanceLabelsReturns(result1 v7action.Warnings, result2 error) {
	fake.updateServiceInstanceLabelsMutex.Lock()
	defer fake.updateServiceInstanceLabelsMutex.Unlock()
	fake.UpdateServiceInstanceLabelsStub = nil
	fake.updateServiceInstanceLabelsReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceInstanceLabelsReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateServiceInstanceLabelsMutex.Lock()
	defer fake.updateServiceInstanceLabelsMutex.Unlock()
	fake.UpdateServiceInstanceLabelsStub = nil
	if fake.updateServiceInstanceLabelsReturnsOnCall == nil {
		fake.updateServiceInstanceLabelsReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateServiceInstanceLabelsReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceOfferingLabels(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateServiceOfferingLabelsMutex.Lock()
	ret, specificReturn := fake.updateServiceOfferingLabelsReturnsOnCall[len(fake.updateServiceOfferingLabelsArgsForCall)]
	fake.updateServiceOfferingLabelsArgsForCall = append(fake.updateServiceOfferingLabelsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateServiceOfferingLabels", []interface{}{arg1, arg2, arg3})
	fake.updateServiceOfferingLabelsMutex.Unlock()
	if fake.UpdateServiceOfferingLabelsStub != nil {
		return fake.UpdateServiceOfferingLabelsStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateServiceOfferingLabelsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateServiceOfferingLabelsCallCount() int {
	fake.updateServiceOfferingLabelsMutex.RLock()
	defer fake.updateServiceOfferingLabelsMutex.RUnlock()
	return len(fake.updateServiceOfferingLabelsArgsForCall)
}

func (fake *FakeActor) UpdateServiceOfferingLabelsCalls(stub func(string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateServiceOfferingLabelsMutex.Lock()
	defer fake.updateServiceOfferingLabelsMutex.Unlock()
	fake.UpdateServiceOfferingLabelsStub = stub
}

func (fake *FakeActor) UpdateServiceOfferingLabelsArgsForCall(i int) (string, string, map[string]types.NullString) {
	fake.updateServiceOfferingLabelsMutex.RLock()
	defer fake.updateServiceOfferingLabelsMutex.RUnlock()
	argsForCall := fake.updateServiceOfferingLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateServiceOfferingLabelsReturns(result1 v7action.Warnings, result2 error) {
	fake.updateServiceOfferingLabelsMutex.Lock()
	defer fake.updateServiceOfferingLabelsMutex.Unlock()
	fake.UpdateServiceOfferingLabelsStub = nil
	fake.updateServiceOfferingLabelsReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServiceOfferingLabelsReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateServiceOfferingLabelsMutex.Lock()
	defer fake.updateServiceOfferingLabelsMutex.Unlock()
	fake.UpdateServiceOfferingLabelsStub = nil
	if fake.updateServiceOfferingLabelsReturnsOnCall == nil {
		fake.updateServiceOfferingLabelsReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateServiceOfferingLabelsReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServicePlanLabels(arg1 string, arg2 string, arg3 string, arg4 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateServicePlanLabelsMutex.Lock()
	ret, specificReturn := fake.updateServicePlanLabelsReturnsOnCall[len(fake.updateServicePlanLabelsArgsForCall)]
	fake.updateServicePlanLabelsArgsForCall = append(fake.updateServicePlanLabelsArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 map[string]types.NullString
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UpdateServicePlanLabels", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateServicePlanLabelsMutex.Unlock()
	if fake.UpdateServicePlanLabelsStub != nil {
		return fake.UpdateServicePlanLabelsStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateServicePlanLabelsReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateServicePlanLabelsCallCount() int {
	fake.updateServicePlanLabelsMutex.RLock()
	defer fake.updateServicePlanLabelsMutex.RUnlock()
	return len(fake.updateServicePlanLabelsArgsForCall)
}

func (fake *FakeActor) UpdateServicePlanLabelsCalls(stub func(string, string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateServicePlanLabelsMutex.Lock()
	defer fake.updateServicePlanLabelsMutex.Unlock()
	fake.UpdateServicePlanLabelsStub = stub
}

func (fake *FakeActor) UpdateServicePlanLabelsArgsForCall(i int) (string, string, string, map[string]types.NullString) {
	fake.updateServicePlanLabelsMutex.RLock()
	defer fake.updateServicePlanLabelsMutex.RUnlock()
	argsForCall := fake.updateServicePlanLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UpdateServicePlanLabelsReturns(result1 v7action.Warnings, result2 error) {
	fake.updateServicePlanLabelsMutex.Lock()
	defer fake.updateServicePlanLabelsMutex.Unlock()
	fake.UpdateServicePlanLabelsStub = nil
	fake.updateServicePlanLabelsReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateServicePlanLabelsReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateServicePlanLabelsMutex.Lock()
	defer fake.updateServicePlanLabelsMutex.Unlock()
	fake.UpdateServicePlanLabelsStub = nil
	if fake.updateServicePlanLabelsReturnsOnCall == nil {
		fake.updateServicePlanLabelsReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateServicePlanLabelsReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSpaceFeature(arg1 string, arg2 string, arg3 bool, arg4 string) (v7action.Warnings, error) {
	fake.updateSpaceFeatureMutex.Lock()
	ret, specificReturn := fake.updateSpaceFeatureReturnsOnCall[len(fake.updateSpaceFeatureArgsForCall)]
	fake.updateSpaceFeatureArgsForCall = append(fake.updateSpaceFeatureArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 bool
		arg4 string
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UpdateSpaceFeature", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateSpaceFeatureMutex.Unlock()
	if fake.UpdateSpaceFeatureStub != nil {
		return fake.UpdateSpaceFeatureStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceFeatureReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateSpaceFeatureCallCount() int {
	fake.updateSpaceFeatureMutex.RLock()
	defer fake.updateSpaceFeatureMutex.RUnlock()
	return len(fake.updateSpaceFeatureArgsForCall)
}

func (fake *FakeActor) UpdateSpaceFeatureCalls(stub func(string, string, bool, string) (v7action.Warnings, error)) {
	fake.updateSpaceFeatureMutex.Lock()
	defer fake.updateSpaceFeatureMutex.Unlock()
	fake.UpdateSpaceFeatureStub = stub
}

func (fake *FakeActor) UpdateSpaceFeatureArgsForCall(i int) (string, string, bool, string) {
	fake.updateSpaceFeatureMutex.RLock()
	defer fake.updateSpaceFeatureMutex.RUnlock()
	argsForCall := fake.updateSpaceFeatureArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UpdateSpaceFeatureReturns(result1 v7action.Warnings, result2 error) {
	fake.updateSpaceFeatureMutex.Lock()
	defer fake.updateSpaceFeatureMutex.Unlock()
	fake.UpdateSpaceFeatureStub = nil
	fake.updateSpaceFeatureReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSpaceFeatureReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateSpaceFeatureMutex.Lock()
	defer fake.updateSpaceFeatureMutex.Unlock()
	fake.UpdateSpaceFeatureStub = nil
	if fake.updateSpaceFeatureReturnsOnCall == nil {
		fake.updateSpaceFeatureReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateSpaceFeatureReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSpaceLabelsBySpaceName(arg1 string, arg2 string, arg3 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateSpaceLabelsBySpaceNameMutex.Lock()
	ret, specificReturn := fake.updateSpaceLabelsBySpaceNameReturnsOnCall[len(fake.updateSpaceLabelsBySpaceNameArgsForCall)]
	fake.updateSpaceLabelsBySpaceNameArgsForCall = append(fake.updateSpaceLabelsBySpaceNameArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 map[string]types.NullString
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateSpaceLabelsBySpaceName", []interface{}{arg1, arg2, arg3})
	fake.updateSpaceLabelsBySpaceNameMutex.Unlock()
	if fake.UpdateSpaceLabelsBySpaceNameStub != nil {
		return fake.UpdateSpaceLabelsBySpaceNameStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceLabelsBySpaceNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameCallCount() int {
	fake.updateSpaceLabelsBySpaceNameMutex.RLock()
	defer fake.updateSpaceLabelsBySpaceNameMutex.RUnlock()
	return len(fake.updateSpaceLabelsBySpaceNameArgsForCall)
}

func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameCalls(stub func(string, string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateSpaceLabelsBySpaceNameMutex.Lock()
	defer fake.updateSpaceLabelsBySpaceNameMutex.Unlock()
	fake.UpdateSpaceLabelsBySpaceNameStub = stub
}

func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameArgsForCall(i int) (string, string, map[string]types.NullString) {
	fake.updateSpaceLabelsBySpaceNameMutex.RLock()
	defer fake.updateSpaceLabelsBySpaceNameMutex.RUnlock()
	argsForCall := fake.updateSpaceLabelsBySpaceNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameReturns(result1 v7action.Warnings, result2 error) {
	fake.updateSpaceLabelsBySpaceNameMutex.Lock()
	defer fake.updateSpaceLabelsBySpaceNameMutex.Unlock()
	fake.UpdateSpaceLabelsBySpaceNameStub = nil
	fake.updateSpaceLabelsBySpaceNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSpaceLabelsBySpaceNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateSpaceLabelsBySpaceNameMutex.Lock()
	defer fake.updateSpaceLabelsBySpaceNameMutex.Unlock()
	fake.UpdateSpaceLabelsBySpaceNameStub = nil
	if fake.updateSpaceLabelsBySpaceNameReturnsOnCall == nil {
		fake.updateSpaceLabelsBySpaceNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateSpaceLabelsBySpaceNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSpaceQuota(arg1 string, arg2 string, arg3 string, arg4 v7action.QuotaLimits) (v7action.Warnings, error) {
	fake.updateSpaceQuotaMutex.Lock()
	ret, specificReturn := fake.updateSpaceQuotaReturnsOnCall[len(fake.updateSpaceQuotaArgsForCall)]
	fake.updateSpaceQuotaArgsForCall = append(fake.updateSpaceQuotaArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 v7action.QuotaLimits
	}{arg1, arg2, arg3, arg4})
	fake.recordInvocation("UpdateSpaceQuota", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateSpaceQuotaMutex.Unlock()
	if fake.UpdateSpaceQuotaStub != nil {
		return fake.UpdateSpaceQuotaStub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateSpaceQuotaReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateSpaceQuotaCallCount() int {
	fake.updateSpaceQuotaMutex.RLock()
	defer fake.updateSpaceQuotaMutex.RUnlock()
	return len(fake.updateSpaceQuotaArgsForCall)
}

func (fake *FakeActor) UpdateSpaceQuotaCalls(stub func(string, string, string, v7action.QuotaLimits) (v7action.Warnings, error)) {
	fake.updateSpaceQuotaMutex.Lock()
	defer fake.updateSpaceQuotaMutex.Unlock()
	fake.UpdateSpaceQuotaStub = stub
}

func (fake *FakeActor) UpdateSpaceQuotaArgsForCall(i int) (string, string, string, v7action.QuotaLimits) {
	fake.updateSpaceQuotaMutex.RLock()
	defer fake.updateSpaceQuotaMutex.RUnlock()
	argsForCall := fake.updateSpaceQuotaArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UpdateSpaceQuotaReturns(result1 v7action.Warnings, result2 error) {
	fake.updateSpaceQuotaMutex.Lock()
	defer fake.updateSpaceQuotaMutex.Unlock()
	fake.UpdateSpaceQuotaStub = nil
	fake.updateSpaceQuotaReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateSpaceQuotaReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateSpaceQuotaMutex.Lock()
	defer fake.updateSpaceQuotaMutex.Unlock()
	fake.UpdateSpaceQuotaStub = nil
	if fake.updateSpaceQuotaReturnsOnCall == nil {
		fake.updateSpaceQuotaReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateSpaceQuotaReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateStackLabelsByStackName(arg1 string, arg2 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateStackLabelsByStackNameMutex.Lock()
	ret, specificReturn := fake.updateStackLabelsByStackNameReturnsOnCall[len(fake.updateStackLabelsByStackNameArgsForCall)]
	fake.updateStackLabelsByStackNameArgsForCall = append(fake.updateStackLabelsByStackNameArgsForCall, struct {
		arg1 string
		arg2 map[string]types.NullString
	}{arg1, arg2})
	fake.recordInvocation("UpdateStackLabelsByStackName", []interface{}{arg1, arg2})
	fake.updateStackLabelsByStackNameMutex.Unlock()
	if fake.UpdateStackLabelsByStackNameStub != nil {
		return fake.UpdateStackLabelsByStackNameStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateStackLabelsByStackNameReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateStackLabelsByStackNameCallCount() int {
	fake.updateStackLabelsByStackNameMutex.RLock()
	defer fake.updateStackLabelsByStackNameMutex.RUnlock()
	return len(fake.updateStackLabelsByStackNameArgsForCall)
}

func (fake *FakeActor) UpdateStackLabelsByStackNameCalls(stub func(string, map[string]types.NullString) (v7action.Warnings, error)) {
	fake.updateStackLabelsByStackNameMutex.Lock()
	defer fake.updateStackLabelsByStackNameMutex.Unlock()
	fake.UpdateStackLabelsByStackNameStub = stub
}

func (fake *FakeActor) UpdateStackLabelsByStackNameArgsForCall(i int) (string, map[string]types.NullString) {
	fake.updateStackLabelsByStackNameMutex.RLock()
	defer fake.updateStackLabelsByStackNameMutex.RUnlock()
	argsForCall := fake.updateStackLabelsByStackNameArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateStackLabelsByStackNameReturns(result1 v7action.Warnings, result2 error) {
	fake.updateStackLabelsByStackNameMutex.Lock()
	defer fake.updateStackLabelsByStackNameMutex.Unlock()
	fake.UpdateStackLabelsByStackNameStub = nil
	fake.updateStackLabelsByStackNameReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateStackLabelsByStackNameReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateStackLabelsByStackNameMutex.Lock()
	defer fake.updateStackLabelsByStackNameMutex.Unlock()
	fake.UpdateStackLabelsByStackNameStub = nil
	if fake.updateStackLabelsByStackNameReturnsOnCall == nil {
		fake.updateStackLabelsByStackNameReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateStackLabelsByStackNameReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateUserPassword(arg1 string, arg2 string, arg3 string) error {
	fake.updateUserPasswordMutex.Lock()
	ret, specificReturn := fake.updateUserPasswordReturnsOnCall[len(fake.updateUserPasswordArgsForCall)]
	fake.updateUserPasswordArgsForCall = append(fake.updateUserPasswordArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateUserPassword", []interface{}{arg1, arg2, arg3})
	fake.updateUserPasswordMutex.Unlock()
	if fake.UpdateUserPasswordStub != nil {
		return fake.UpdateUserPasswordStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	fakeReturns := fake.updateUserPasswordReturns
	return fakeReturns.result1
}

func (fake *FakeActor) UpdateUserPasswordCallCount() int {
	fake.updateUserPasswordMutex.RLock()
	defer fake.updateUserPasswordMutex.RUnlock()
	return len(fake.updateUserPasswordArgsForCall)
}

func (fake *FakeActor) UpdateUserPasswordCalls(stub func(string, string, string) error) {
	fake.updateUserPasswordMutex.Lock()
	defer fake.updateUserPasswordMutex.Unlock()
	fake.UpdateUserPasswordStub = stub
}

func (fake *FakeActor) UpdateUserPasswordArgsForCall(i int) (string, string, string) {
	fake.updateUserPasswordMutex.RLock()
	defer fake.updateUserPasswordMutex.RUnlock()
	argsForCall := fake.updateUserPasswordArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateUserPasswordReturns(result1 error) {
	fake.updateUserPasswordMutex.Lock()
	defer fake.updateUserPasswordMutex.Unlock()
	fake.UpdateUserPasswordStub = nil
	fake.updateUserPasswordReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeActor) UpdateUserPasswordReturnsOnCall(i int, result1 error) {
	fake.updateUserPasswordMutex.Lock()
	defer fake.updateUserPasswordMutex.Unlock()
	fake.UpdateUserPasswordStub = nil
	if fake.updateUserPasswordReturnsOnCall == nil {
		fake.updateUserPasswordReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateUserPasswordReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeActor) UpdateUserProvidedServiceInstance(arg1 string, arg2 string, arg3 resources.ServiceInstance) (v7action.Warnings, error) {
	fake.updateUserProvidedServiceInstanceMutex.Lock()
	ret, specificReturn := fake.updateUserProvidedServiceInstanceReturnsOnCall[len(fake.updateUserProvidedServiceInstanceArgsForCall)]
	fake.updateUserProvidedServiceInstanceArgsForCall = append(fake.updateUserProvidedServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 resources.ServiceInstance
	}{arg1, arg2, arg3})
	fake.recordInvocation("UpdateUserProvidedServiceInstance", []interface{}{arg1, arg2, arg3})
	fake.updateUserProvidedServiceInstanceMutex.Unlock()
	if fake.UpdateUserProvidedServiceInstanceStub != nil {
		return fake.UpdateUserProvidedServiceInstanceStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	fakeReturns := fake.updateUserProvidedServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateUserProvidedServiceInstanceCallCount() int {
	fake.updateUserProvidedServiceInstanceMutex.RLock()
	defer fake.updateUserProvidedServiceInstanceMutex.RUnlock()
	return len(fake.updateUserProvidedServiceInstanceArgsForCall)
}

func (fake *FakeActor) UpdateUserProvidedServiceInstanceCalls(stub func(string, string, resources.ServiceInstance) (v7action.Warnings, error)) {
	fake.updateUserProvidedServiceInstanceMutex.Lock()
	defer fake.updateUserProvidedServiceInstanceMutex.Unlock()
	fake.UpdateUserProvidedServiceInstanceStub = stub
}

func (fake *FakeActor) UpdateUserProvidedServiceInstanceArgsForCall(i int) (string, string, resources.ServiceInstance) {
	fake.updateUserProvidedServiceInstanceMutex.RLock()
	defer fake.updateUserProvidedServiceInstanceMutex.RUnlock()
	argsForCall := fake.updateUserProvidedServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UpdateUserProvidedServiceInstanceReturns(result1 v7action.Warnings, result2 error) {
	fake.updateUserProvidedServiceInstanceMutex.Lock()
	defer fake.updateUserProvidedServiceInstanceMutex.Unlock()
	fake.UpdateUserProvidedServiceInstanceStub = nil
	fake.updateUserProvidedServiceInstanceReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateUserProvidedServiceInstanceReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateUserProvidedServiceInstanceMutex.Lock()
	defer fake.updateUserProvidedServiceInstanceMutex.Unlock()
	fake.UpdateUserProvidedServiceInstanceStub = nil
	if fake.updateUserProvidedServiceInstanceReturnsOnCall == nil {
		fake.updateUserProvidedServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateUserProvidedServiceInstanceReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpgradeManagedServiceInstance(arg1 string, arg2 string) (chan v7action.PollJobEvent, v7action.Warnings, error) {
	fake.upgradeManagedServiceInstanceMutex.Lock()
	ret, specificReturn := fake.upgradeManagedServiceInstanceReturnsOnCall[len(fake.upgradeManagedServiceInstanceArgsForCall)]
	fake.upgradeManagedServiceInstanceArgsForCall = append(fake.upgradeManagedServiceInstanceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	fake.recordInvocation("UpgradeManagedServiceInstance", []interface{}{arg1, arg2})
	fake.upgradeManagedServiceInstanceMutex.Unlock()
	if fake.UpgradeManagedServiceInstanceStub != nil {
		return fake.UpgradeManagedServiceInstanceStub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.upgradeManagedServiceInstanceReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) UpgradeManagedServiceInstanceCallCount() int {
	fake.upgradeManagedServiceInstanceMutex.RLock()
	defer fake.upgradeManagedServiceInstanceMutex.RUnlock()
	return len(fake.upgradeManagedServiceInstanceArgsForCall)
}

func (fake *FakeActor) UpgradeManagedServiceInstanceCalls(stub func(string, string) (chan v7action.PollJobEvent, v7action.Warnings, error)) {
	fake.upgradeManagedServiceInstanceMutex.Lock()
	defer fake.upgradeManagedServiceInstanceMutex.Unlock()
	fake.UpgradeManagedServiceInstanceStub = stub
}

func (fake *FakeActor) UpgradeManagedServiceInstanceArgsForCall(i int) (string, string) {
	fake.upgradeManagedServiceInstanceMutex.RLock()
	defer fake.upgradeManagedServiceInstanceMutex.RUnlock()
	argsForCall := fake.upgradeManagedServiceInstanceArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpgradeManagedServiceInstanceReturns(result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.upgradeManagedServiceInstanceMutex.Lock()
	defer fake.upgradeManagedServiceInstanceMutex.Unlock()
	fake.UpgradeManagedServiceInstanceStub = nil
	fake.upgradeManagedServiceInstanceReturns = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpgradeManagedServiceInstanceReturnsOnCall(i int, result1 chan v7action.PollJobEvent, result2 v7action.Warnings, result3 error) {
	fake.upgradeManagedServiceInstanceMutex.Lock()
	defer fake.upgradeManagedServiceInstanceMutex.Unlock()
	fake.UpgradeManagedServiceInstanceStub = nil
	if fake.upgradeManagedServiceInstanceReturnsOnCall == nil {
		fake.upgradeManagedServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 chan v7action.PollJobEvent
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.upgradeManagedServiceInstanceReturnsOnCall[i] = struct {
		result1 chan v7action.PollJobEvent
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UploadBitsPackage(arg1 resources.Package, arg2 []sharedaction.V3Resource, arg3 io.Reader, arg4 int64) (resources.Package, v7action.Warnings, error) {
	var arg2Copy []sharedaction.V3Resource
	if arg2 != nil {
		arg2Copy = make([]sharedaction.V3Resource, 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 []sharedaction.V3Resource
		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 *FakeActor) UploadBitsPackageCallCount() int {
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	return len(fake.uploadBitsPackageArgsForCall)
}

func (fake *FakeActor) UploadBitsPackageCalls(stub func(resources.Package, []sharedaction.V3Resource, io.Reader, int64) (resources.Package, v7action.Warnings, error)) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = stub
}

func (fake *FakeActor) UploadBitsPackageArgsForCall(i int) (resources.Package, []sharedaction.V3Resource, 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 *FakeActor) UploadBitsPackageReturns(result1 resources.Package, result2 v7action.Warnings, result3 error) {
	fake.uploadBitsPackageMutex.Lock()
	defer fake.uploadBitsPackageMutex.Unlock()
	fake.UploadBitsPackageStub = nil
	fake.uploadBitsPackageReturns = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UploadBitsPackageReturnsOnCall(i int, result1 resources.Package, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.uploadBitsPackageReturnsOnCall[i] = struct {
		result1 resources.Package
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UploadBuildpack(arg1 string, arg2 string, arg3 v7action.SimpleProgressBar) (ccv3.JobURL, v7action.Warnings, error) {
	fake.uploadBuildpackMutex.Lock()
	ret, specificReturn := fake.uploadBuildpackReturnsOnCall[len(fake.uploadBuildpackArgsForCall)]
	fake.uploadBuildpackArgsForCall = append(fake.uploadBuildpackArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 v7action.SimpleProgressBar
	}{arg1, arg2, arg3})
	fake.recordInvocation("UploadBuildpack", []interface{}{arg1, arg2, arg3})
	fake.uploadBuildpackMutex.Unlock()
	if fake.UploadBuildpackStub != nil {
		return fake.UploadBuildpackStub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	fakeReturns := fake.uploadBuildpackReturns
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

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

func (fake *FakeActor) UploadBuildpackCalls(stub func(string, string, v7action.SimpleProgressBar) (ccv3.JobURL, v7action.Warnings, error)) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = stub
}

func (fake *FakeActor) UploadBuildpackArgsForCall(i int) (string, string, v7action.SimpleProgressBar) {
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	argsForCall := fake.uploadBuildpackArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeActor) UploadBuildpackReturns(result1 ccv3.JobURL, result2 v7action.Warnings, result3 error) {
	fake.uploadBuildpackMutex.Lock()
	defer fake.uploadBuildpackMutex.Unlock()
	fake.UploadBuildpackStub = nil
	fake.uploadBuildpackReturns = struct {
		result1 ccv3.JobURL
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UploadBuildpackReturnsOnCall(i int, result1 ccv3.JobURL, result2 v7action.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 v7action.Warnings
			result3 error
		})
	}
	fake.uploadBuildpackReturnsOnCall[i] = struct {
		result1 ccv3.JobURL
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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

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

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

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

func (fake *FakeActor) UploadDropletReturns(result1 v7action.Warnings, result2 error) {
	fake.uploadDropletMutex.Lock()
	defer fake.uploadDropletMutex.Unlock()
	fake.UploadDropletStub = nil
	fake.uploadDropletReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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

func (fake *FakeActor) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.applyOrganizationQuotaByNameMutex.RLock()
	defer fake.applyOrganizationQuotaByNameMutex.RUnlock()
	fake.applySpaceQuotaByNameMutex.RLock()
	defer fake.applySpaceQuotaByNameMutex.RUnlock()
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RLock()
	defer fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.RUnlock()
	fake.authenticateMutex.RLock()
	defer fake.authenticateMutex.RUnlock()
	fake.bindSecurityGroupToSpacesMutex.RLock()
	defer fake.bindSecurityGroupToSpacesMutex.RUnlock()
	fake.cancelDeploymentMutex.RLock()
	defer fake.cancelDeploymentMutex.RUnlock()
	fake.checkRouteMutex.RLock()
	defer fake.checkRouteMutex.RUnlock()
	fake.clearTargetMutex.RLock()
	defer fake.clearTargetMutex.RUnlock()
	fake.copyPackageMutex.RLock()
	defer fake.copyPackageMutex.RUnlock()
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RLock()
	defer fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.RUnlock()
	fake.createApplicationDropletMutex.RLock()
	defer fake.createApplicationDropletMutex.RUnlock()
	fake.createApplicationInSpaceMutex.RLock()
	defer fake.createApplicationInSpaceMutex.RUnlock()
	fake.createBitsPackageByApplicationMutex.RLock()
	defer fake.createBitsPackageByApplicationMutex.RUnlock()
	fake.createBuildpackMutex.RLock()
	defer fake.createBuildpackMutex.RUnlock()
	fake.createDeploymentByApplicationAndDropletMutex.RLock()
	defer fake.createDeploymentByApplicationAndDropletMutex.RUnlock()
	fake.createDeploymentByApplicationAndRevisionMutex.RLock()
	defer fake.createDeploymentByApplicationAndRevisionMutex.RUnlock()
	fake.createDockerPackageByApplicationMutex.RLock()
	defer fake.createDockerPackageByApplicationMutex.RUnlock()
	fake.createDockerPackageByApplicationNameAndSpaceMutex.RLock()
	defer fake.createDockerPackageByApplicationNameAndSpaceMutex.RUnlock()
	fake.createIsolationSegmentByNameMutex.RLock()
	defer fake.createIsolationSegmentByNameMutex.RUnlock()
	fake.createManagedServiceInstanceMutex.RLock()
	defer fake.createManagedServiceInstanceMutex.RUnlock()
	fake.createOrgRoleMutex.RLock()
	defer fake.createOrgRoleMutex.RUnlock()
	fake.createOrganizationMutex.RLock()
	defer fake.createOrganizationMutex.RUnlock()
	fake.createOrganizationQuotaMutex.RLock()
	defer fake.createOrganizationQuotaMutex.RUnlock()
	fake.createPrivateDomainMutex.RLock()
	defer fake.createPrivateDomainMutex.RUnlock()
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	fake.createRouteBindingMutex.RLock()
	defer fake.createRouteBindingMutex.RUnlock()
	fake.createSecurityGroupMutex.RLock()
	defer fake.createSecurityGroupMutex.RUnlock()
	fake.createServiceAppBindingMutex.RLock()
	defer fake.createServiceAppBindingMutex.RUnlock()
	fake.createServiceBrokerMutex.RLock()
	defer fake.createServiceBrokerMutex.RUnlock()
	fake.createServiceKeyMutex.RLock()
	defer fake.createServiceKeyMutex.RUnlock()
	fake.createSharedDomainMutex.RLock()
	defer fake.createSharedDomainMutex.RUnlock()
	fake.createSpaceMutex.RLock()
	defer fake.createSpaceMutex.RUnlock()
	fake.createSpaceQuotaMutex.RLock()
	defer fake.createSpaceQuotaMutex.RUnlock()
	fake.createSpaceRoleMutex.RLock()
	defer fake.createSpaceRoleMutex.RUnlock()
	fake.createUserMutex.RLock()
	defer fake.createUserMutex.RUnlock()
	fake.createUserProvidedServiceInstanceMutex.RLock()
	defer fake.createUserProvidedServiceInstanceMutex.RUnlock()
	fake.deleteApplicationByNameAndSpaceMutex.RLock()
	defer fake.deleteApplicationByNameAndSpaceMutex.RUnlock()
	fake.deleteBuildpackByNameAndStackMutex.RLock()
	defer fake.deleteBuildpackByNameAndStackMutex.RUnlock()
	fake.deleteDomainMutex.RLock()
	defer fake.deleteDomainMutex.RUnlock()
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RLock()
	defer fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock()
	fake.deleteIsolationSegmentByNameMutex.RLock()
	defer fake.deleteIsolationSegmentByNameMutex.RUnlock()
	fake.deleteIsolationSegmentOrganizationByNameMutex.RLock()
	defer fake.deleteIsolationSegmentOrganizationByNameMutex.RUnlock()
	fake.deleteOrgRoleMutex.RLock()
	defer fake.deleteOrgRoleMutex.RUnlock()
	fake.deleteOrganizationMutex.RLock()
	defer fake.deleteOrganizationMutex.RUnlock()
	fake.deleteOrganizationQuotaMutex.RLock()
	defer fake.deleteOrganizationQuotaMutex.RUnlock()
	fake.deleteOrphanedRoutesMutex.RLock()
	defer fake.deleteOrphanedRoutesMutex.RUnlock()
	fake.deleteRouteMutex.RLock()
	defer fake.deleteRouteMutex.RUnlock()
	fake.deleteRouteBindingMutex.RLock()
	defer fake.deleteRouteBindingMutex.RUnlock()
	fake.deleteSecurityGroupMutex.RLock()
	defer fake.deleteSecurityGroupMutex.RUnlock()
	fake.deleteServiceAppBindingMutex.RLock()
	defer fake.deleteServiceAppBindingMutex.RUnlock()
	fake.deleteServiceBrokerMutex.RLock()
	defer fake.deleteServiceBrokerMutex.RUnlock()
	fake.deleteServiceInstanceMutex.RLock()
	defer fake.deleteServiceInstanceMutex.RUnlock()
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.RLock()
	defer fake.deleteServiceKeyByServiceInstanceAndNameMutex.RUnlock()
	fake.deleteSpaceByNameAndOrganizationNameMutex.RLock()
	defer fake.deleteSpaceByNameAndOrganizationNameMutex.RUnlock()
	fake.deleteSpaceQuotaByNameMutex.RLock()
	defer fake.deleteSpaceQuotaByNameMutex.RUnlock()
	fake.deleteSpaceRoleMutex.RLock()
	defer fake.deleteSpaceRoleMutex.RUnlock()
	fake.deleteUserMutex.RLock()
	defer fake.deleteUserMutex.RUnlock()
	fake.diffSpaceManifestMutex.RLock()
	defer fake.diffSpaceManifestMutex.RUnlock()
	fake.disableFeatureFlagMutex.RLock()
	defer fake.disableFeatureFlagMutex.RUnlock()
	fake.disableServiceAccessMutex.RLock()
	defer fake.disableServiceAccessMutex.RUnlock()
	fake.downloadCurrentDropletByAppNameMutex.RLock()
	defer fake.downloadCurrentDropletByAppNameMutex.RUnlock()
	fake.downloadDropletByGUIDAndAppNameMutex.RLock()
	defer fake.downloadDropletByGUIDAndAppNameMutex.RUnlock()
	fake.enableFeatureFlagMutex.RLock()
	defer fake.enableFeatureFlagMutex.RUnlock()
	fake.enableServiceAccessMutex.RLock()
	defer fake.enableServiceAccessMutex.RUnlock()
	fake.entitleIsolationSegmentToOrganizationByNameMutex.RLock()
	defer fake.entitleIsolationSegmentToOrganizationByNameMutex.RUnlock()
	fake.getAppFeatureMutex.RLock()
	defer fake.getAppFeatureMutex.RUnlock()
	fake.getAppSummariesForSpaceMutex.RLock()
	defer fake.getAppSummariesForSpaceMutex.RUnlock()
	fake.getApplicationByNameAndSpaceMutex.RLock()
	defer fake.getApplicationByNameAndSpaceMutex.RUnlock()
	fake.getApplicationDropletsMutex.RLock()
	defer fake.getApplicationDropletsMutex.RUnlock()
	fake.getApplicationLabelsMutex.RLock()
	defer fake.getApplicationLabelsMutex.RUnlock()
	fake.getApplicationMapForRouteMutex.RLock()
	defer fake.getApplicationMapForRouteMutex.RUnlock()
	fake.getApplicationPackagesMutex.RLock()
	defer fake.getApplicationPackagesMutex.RUnlock()
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RLock()
	defer fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.RUnlock()
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	fake.getApplicationsByNamesAndSpaceMutex.RLock()
	defer fake.getApplicationsByNamesAndSpaceMutex.RUnlock()
	fake.getBuildpackLabelsMutex.RLock()
	defer fake.getBuildpackLabelsMutex.RUnlock()
	fake.getBuildpacksMutex.RLock()
	defer fake.getBuildpacksMutex.RUnlock()
	fake.getCurrentUserMutex.RLock()
	defer fake.getCurrentUserMutex.RUnlock()
	fake.getDefaultDomainMutex.RLock()
	defer fake.getDefaultDomainMutex.RUnlock()
	fake.getDetailedAppSummaryMutex.RLock()
	defer fake.getDetailedAppSummaryMutex.RUnlock()
	fake.getDomainMutex.RLock()
	defer fake.getDomainMutex.RUnlock()
	fake.getDomainByNameMutex.RLock()
	defer fake.getDomainByNameMutex.RUnlock()
	fake.getDomainLabelsMutex.RLock()
	defer fake.getDomainLabelsMutex.RUnlock()
	fake.getEffectiveIsolationSegmentBySpaceMutex.RLock()
	defer fake.getEffectiveIsolationSegmentBySpaceMutex.RUnlock()
	fake.getEnvironmentVariableGroupMutex.RLock()
	defer fake.getEnvironmentVariableGroupMutex.RUnlock()
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RLock()
	defer fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.RUnlock()
	fake.getFeatureFlagByNameMutex.RLock()
	defer fake.getFeatureFlagByNameMutex.RUnlock()
	fake.getFeatureFlagsMutex.RLock()
	defer fake.getFeatureFlagsMutex.RUnlock()
	fake.getGlobalRunningSecurityGroupsMutex.RLock()
	defer fake.getGlobalRunningSecurityGroupsMutex.RUnlock()
	fake.getGlobalStagingSecurityGroupsMutex.RLock()
	defer fake.getGlobalStagingSecurityGroupsMutex.RUnlock()
	fake.getIsolationSegmentByNameMutex.RLock()
	defer fake.getIsolationSegmentByNameMutex.RUnlock()
	fake.getIsolationSegmentSummariesMutex.RLock()
	defer fake.getIsolationSegmentSummariesMutex.RUnlock()
	fake.getIsolationSegmentsByOrganizationMutex.RLock()
	defer fake.getIsolationSegmentsByOrganizationMutex.RUnlock()
	fake.getLatestActiveDeploymentForAppMutex.RLock()
	defer fake.getLatestActiveDeploymentForAppMutex.RUnlock()
	fake.getLoginPromptsMutex.RLock()
	defer fake.getLoginPromptsMutex.RUnlock()
	fake.getNewestReadyPackageForApplicationMutex.RLock()
	defer fake.getNewestReadyPackageForApplicationMutex.RUnlock()
	fake.getOrgUsersByRoleTypeMutex.RLock()
	defer fake.getOrgUsersByRoleTypeMutex.RUnlock()
	fake.getOrganizationByNameMutex.RLock()
	defer fake.getOrganizationByNameMutex.RUnlock()
	fake.getOrganizationDomainsMutex.RLock()
	defer fake.getOrganizationDomainsMutex.RUnlock()
	fake.getOrganizationLabelsMutex.RLock()
	defer fake.getOrganizationLabelsMutex.RUnlock()
	fake.getOrganizationQuotaByNameMutex.RLock()
	defer fake.getOrganizationQuotaByNameMutex.RUnlock()
	fake.getOrganizationQuotasMutex.RLock()
	defer fake.getOrganizationQuotasMutex.RUnlock()
	fake.getOrganizationSpacesMutex.RLock()
	defer fake.getOrganizationSpacesMutex.RUnlock()
	fake.getOrganizationSpacesWithLabelSelectorMutex.RLock()
	defer fake.getOrganizationSpacesWithLabelSelectorMutex.RUnlock()
	fake.getOrganizationSummaryByNameMutex.RLock()
	defer fake.getOrganizationSummaryByNameMutex.RUnlock()
	fake.getOrganizationsMutex.RLock()
	defer fake.getOrganizationsMutex.RUnlock()
	fake.getProcessByTypeAndApplicationMutex.RLock()
	defer fake.getProcessByTypeAndApplicationMutex.RUnlock()
	fake.getRawApplicationManifestByNameAndSpaceMutex.RLock()
	defer fake.getRawApplicationManifestByNameAndSpaceMutex.RUnlock()
	fake.getRecentEventsByApplicationNameAndSpaceMutex.RLock()
	defer fake.getRecentEventsByApplicationNameAndSpaceMutex.RUnlock()
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.RLock()
	defer fake.getRecentLogsForApplicationByNameAndSpaceMutex.RUnlock()
	fake.getRevisionByApplicationAndVersionMutex.RLock()
	defer fake.getRevisionByApplicationAndVersionMutex.RUnlock()
	fake.getRevisionsByApplicationNameAndSpaceMutex.RLock()
	defer fake.getRevisionsByApplicationNameAndSpaceMutex.RUnlock()
	fake.getRootResponseMutex.RLock()
	defer fake.getRootResponseMutex.RUnlock()
	fake.getRouteByAttributesMutex.RLock()
	defer fake.getRouteByAttributesMutex.RUnlock()
	fake.getRouteDestinationByAppGUIDMutex.RLock()
	defer fake.getRouteDestinationByAppGUIDMutex.RUnlock()
	fake.getRouteLabelsMutex.RLock()
	defer fake.getRouteLabelsMutex.RUnlock()
	fake.getRouteSummariesMutex.RLock()
	defer fake.getRouteSummariesMutex.RUnlock()
	fake.getRouterGroupsMutex.RLock()
	defer fake.getRouterGroupsMutex.RUnlock()
	fake.getRoutesByOrgMutex.RLock()
	defer fake.getRoutesByOrgMutex.RUnlock()
	fake.getRoutesBySpaceMutex.RLock()
	defer fake.getRoutesBySpaceMutex.RUnlock()
	fake.getSSHEnabledMutex.RLock()
	defer fake.getSSHEnabledMutex.RUnlock()
	fake.getSSHEnabledByAppNameMutex.RLock()
	defer fake.getSSHEnabledByAppNameMutex.RUnlock()
	fake.getSSHPasscodeMutex.RLock()
	defer fake.getSSHPasscodeMutex.RUnlock()
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RLock()
	defer fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.RUnlock()
	fake.getSecurityGroupMutex.RLock()
	defer fake.getSecurityGroupMutex.RUnlock()
	fake.getSecurityGroupSummaryMutex.RLock()
	defer fake.getSecurityGroupSummaryMutex.RUnlock()
	fake.getSecurityGroupsMutex.RLock()
	defer fake.getSecurityGroupsMutex.RUnlock()
	fake.getServiceAccessMutex.RLock()
	defer fake.getServiceAccessMutex.RUnlock()
	fake.getServiceBrokerByNameMutex.RLock()
	defer fake.getServiceBrokerByNameMutex.RUnlock()
	fake.getServiceBrokerLabelsMutex.RLock()
	defer fake.getServiceBrokerLabelsMutex.RUnlock()
	fake.getServiceBrokersMutex.RLock()
	defer fake.getServiceBrokersMutex.RUnlock()
	fake.getServiceInstanceByNameAndSpaceMutex.RLock()
	defer fake.getServiceInstanceByNameAndSpaceMutex.RUnlock()
	fake.getServiceInstanceDetailsMutex.RLock()
	defer fake.getServiceInstanceDetailsMutex.RUnlock()
	fake.getServiceInstanceLabelsMutex.RLock()
	defer fake.getServiceInstanceLabelsMutex.RUnlock()
	fake.getServiceInstanceParametersMutex.RLock()
	defer fake.getServiceInstanceParametersMutex.RUnlock()
	fake.getServiceInstancesForSpaceMutex.RLock()
	defer fake.getServiceInstancesForSpaceMutex.RUnlock()
	fake.getServiceKeyByServiceInstanceAndNameMutex.RLock()
	defer fake.getServiceKeyByServiceInstanceAndNameMutex.RUnlock()
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RLock()
	defer fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.RUnlock()
	fake.getServiceKeysByServiceInstanceMutex.RLock()
	defer fake.getServiceKeysByServiceInstanceMutex.RUnlock()
	fake.getServiceOfferingLabelsMutex.RLock()
	defer fake.getServiceOfferingLabelsMutex.RUnlock()
	fake.getServicePlanByNameOfferingAndBrokerMutex.RLock()
	defer fake.getServicePlanByNameOfferingAndBrokerMutex.RUnlock()
	fake.getServicePlanLabelsMutex.RLock()
	defer fake.getServicePlanLabelsMutex.RUnlock()
	fake.getSpaceByNameAndOrganizationMutex.RLock()
	defer fake.getSpaceByNameAndOrganizationMutex.RUnlock()
	fake.getSpaceFeatureMutex.RLock()
	defer fake.getSpaceFeatureMutex.RUnlock()
	fake.getSpaceLabelsMutex.RLock()
	defer fake.getSpaceLabelsMutex.RUnlock()
	fake.getSpaceQuotaByNameMutex.RLock()
	defer fake.getSpaceQuotaByNameMutex.RUnlock()
	fake.getSpaceQuotasByOrgGUIDMutex.RLock()
	defer fake.getSpaceQuotasByOrgGUIDMutex.RUnlock()
	fake.getSpaceSummaryByNameAndOrganizationMutex.RLock()
	defer fake.getSpaceSummaryByNameAndOrganizationMutex.RUnlock()
	fake.getSpaceUsersByRoleTypeMutex.RLock()
	defer fake.getSpaceUsersByRoleTypeMutex.RUnlock()
	fake.getStackByNameMutex.RLock()
	defer fake.getStackByNameMutex.RUnlock()
	fake.getStackLabelsMutex.RLock()
	defer fake.getStackLabelsMutex.RUnlock()
	fake.getStacksMutex.RLock()
	defer fake.getStacksMutex.RUnlock()
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RLock()
	defer fake.getStreamingLogsForApplicationByNameAndSpaceMutex.RUnlock()
	fake.getTaskBySequenceIDAndApplicationMutex.RLock()
	defer fake.getTaskBySequenceIDAndApplicationMutex.RUnlock()
	fake.getUAAAPIVersionMutex.RLock()
	defer fake.getUAAAPIVersionMutex.RUnlock()
	fake.getUnstagedNewestPackageGUIDMutex.RLock()
	defer fake.getUnstagedNewestPackageGUIDMutex.RUnlock()
	fake.getUserMutex.RLock()
	defer fake.getUserMutex.RUnlock()
	fake.makeCurlRequestMutex.RLock()
	defer fake.makeCurlRequestMutex.RUnlock()
	fake.mapRouteMutex.RLock()
	defer fake.mapRouteMutex.RUnlock()
	fake.marketplaceMutex.RLock()
	defer fake.marketplaceMutex.RUnlock()
	fake.moveRouteMutex.RLock()
	defer fake.moveRouteMutex.RUnlock()
	fake.parseAccessTokenMutex.RLock()
	defer fake.parseAccessTokenMutex.RUnlock()
	fake.pollBuildMutex.RLock()
	defer fake.pollBuildMutex.RUnlock()
	fake.pollPackageMutex.RLock()
	defer fake.pollPackageMutex.RUnlock()
	fake.pollStartMutex.RLock()
	defer fake.pollStartMutex.RUnlock()
	fake.pollStartForRollingMutex.RLock()
	defer fake.pollStartForRollingMutex.RUnlock()
	fake.pollTaskMutex.RLock()
	defer fake.pollTaskMutex.RUnlock()
	fake.pollUploadBuildpackJobMutex.RLock()
	defer fake.pollUploadBuildpackJobMutex.RUnlock()
	fake.prepareBuildpackBitsMutex.RLock()
	defer fake.prepareBuildpackBitsMutex.RUnlock()
	fake.purgeServiceInstanceMutex.RLock()
	defer fake.purgeServiceInstanceMutex.RUnlock()
	fake.purgeServiceOfferingByNameAndBrokerMutex.RLock()
	defer fake.purgeServiceOfferingByNameAndBrokerMutex.RUnlock()
	fake.refreshAccessTokenMutex.RLock()
	defer fake.refreshAccessTokenMutex.RUnlock()
	fake.renameApplicationByNameAndSpaceGUIDMutex.RLock()
	defer fake.renameApplicationByNameAndSpaceGUIDMutex.RUnlock()
	fake.renameOrganizationMutex.RLock()
	defer fake.renameOrganizationMutex.RUnlock()
	fake.renameServiceInstanceMutex.RLock()
	defer fake.renameServiceInstanceMutex.RUnlock()
	fake.renameSpaceByNameAndOrganizationGUIDMutex.RLock()
	defer fake.renameSpaceByNameAndOrganizationGUIDMutex.RUnlock()
	fake.resetOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.resetOrganizationDefaultIsolationSegmentMutex.RUnlock()
	fake.resetSpaceIsolationSegmentMutex.RLock()
	defer fake.resetSpaceIsolationSegmentMutex.RUnlock()
	fake.resourceMatchMutex.RLock()
	defer fake.resourceMatchMutex.RUnlock()
	fake.restartApplicationMutex.RLock()
	defer fake.restartApplicationMutex.RUnlock()
	fake.revokeAccessAndRefreshTokensMutex.RLock()
	defer fake.revokeAccessAndRefreshTokensMutex.RUnlock()
	fake.runTaskMutex.RLock()
	defer fake.runTaskMutex.RUnlock()
	fake.scaleProcessByApplicationMutex.RLock()
	defer fake.scaleProcessByApplicationMutex.RUnlock()
	fake.scheduleTokenRefreshMutex.RLock()
	defer fake.scheduleTokenRefreshMutex.RUnlock()
	fake.setApplicationDropletMutex.RLock()
	defer fake.setApplicationDropletMutex.RUnlock()
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.RLock()
	defer fake.setApplicationDropletByApplicationNameAndSpaceMutex.RUnlock()
	fake.setApplicationManifestMutex.RLock()
	defer fake.setApplicationManifestMutex.RUnlock()
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RLock()
	defer fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.RUnlock()
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RLock()
	defer fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock()
	fake.setEnvironmentVariableGroupMutex.RLock()
	defer fake.setEnvironmentVariableGroupMutex.RUnlock()
	fake.setOrganizationDefaultIsolationSegmentMutex.RLock()
	defer fake.setOrganizationDefaultIsolationSegmentMutex.RUnlock()
	fake.setSpaceManifestMutex.RLock()
	defer fake.setSpaceManifestMutex.RUnlock()
	fake.setTargetMutex.RLock()
	defer fake.setTargetMutex.RUnlock()
	fake.sharePrivateDomainMutex.RLock()
	defer fake.sharePrivateDomainMutex.RUnlock()
	fake.shareRouteMutex.RLock()
	defer fake.shareRouteMutex.RUnlock()
	fake.shareServiceInstanceToSpaceAndOrgMutex.RLock()
	defer fake.shareServiceInstanceToSpaceAndOrgMutex.RUnlock()
	fake.stageApplicationPackageMutex.RLock()
	defer fake.stageApplicationPackageMutex.RUnlock()
	fake.stagePackageMutex.RLock()
	defer fake.stagePackageMutex.RUnlock()
	fake.startApplicationMutex.RLock()
	defer fake.startApplicationMutex.RUnlock()
	fake.stopApplicationMutex.RLock()
	defer fake.stopApplicationMutex.RUnlock()
	fake.terminateTaskMutex.RLock()
	defer fake.terminateTaskMutex.RUnlock()
	fake.unbindSecurityGroupMutex.RLock()
	defer fake.unbindSecurityGroupMutex.RUnlock()
	fake.unmapRouteMutex.RLock()
	defer fake.unmapRouteMutex.RUnlock()
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RLock()
	defer fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.RUnlock()
	fake.unsetSpaceQuotaMutex.RLock()
	defer fake.unsetSpaceQuotaMutex.RUnlock()
	fake.unsharePrivateDomainMutex.RLock()
	defer fake.unsharePrivateDomainMutex.RUnlock()
	fake.unshareRouteMutex.RLock()
	defer fake.unshareRouteMutex.RUnlock()
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.RLock()
	defer fake.unshareServiceInstanceFromSpaceAndOrgMutex.RUnlock()
	fake.updateAppFeatureMutex.RLock()
	defer fake.updateAppFeatureMutex.RUnlock()
	fake.updateApplicationMutex.RLock()
	defer fake.updateApplicationMutex.RUnlock()
	fake.updateApplicationLabelsByApplicationNameMutex.RLock()
	defer fake.updateApplicationLabelsByApplicationNameMutex.RUnlock()
	fake.updateBuildpackByNameAndStackMutex.RLock()
	defer fake.updateBuildpackByNameAndStackMutex.RUnlock()
	fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.RLock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackMutex.RUnlock()
	fake.updateDestinationMutex.RLock()
	defer fake.updateDestinationMutex.RUnlock()
	fake.updateDomainLabelsByDomainNameMutex.RLock()
	defer fake.updateDomainLabelsByDomainNameMutex.RUnlock()
	fake.updateManagedServiceInstanceMutex.RLock()
	defer fake.updateManagedServiceInstanceMutex.RUnlock()
	fake.updateOrganizationLabelsByOrganizationNameMutex.RLock()
	defer fake.updateOrganizationLabelsByOrganizationNameMutex.RUnlock()
	fake.updateOrganizationQuotaMutex.RLock()
	defer fake.updateOrganizationQuotaMutex.RUnlock()
	fake.updateProcessByTypeAndApplicationMutex.RLock()
	defer fake.updateProcessByTypeAndApplicationMutex.RUnlock()
	fake.updateRouteLabelsMutex.RLock()
	defer fake.updateRouteLabelsMutex.RUnlock()
	fake.updateSecurityGroupMutex.RLock()
	defer fake.updateSecurityGroupMutex.RUnlock()
	fake.updateSecurityGroupGloballyEnabledMutex.RLock()
	defer fake.updateSecurityGroupGloballyEnabledMutex.RUnlock()
	fake.updateServiceBrokerMutex.RLock()
	defer fake.updateServiceBrokerMutex.RUnlock()
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RLock()
	defer fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.RUnlock()
	fake.updateServiceInstanceLabelsMutex.RLock()
	defer fake.updateServiceInstanceLabelsMutex.RUnlock()
	fake.updateServiceOfferingLabelsMutex.RLock()
	defer fake.updateServiceOfferingLabelsMutex.RUnlock()
	fake.updateServicePlanLabelsMutex.RLock()
	defer fake.updateServicePlanLabelsMutex.RUnlock()
	fake.updateSpaceFeatureMutex.RLock()
	defer fake.updateSpaceFeatureMutex.RUnlock()
	fake.updateSpaceLabelsBySpaceNameMutex.RLock()
	defer fake.updateSpaceLabelsBySpaceNameMutex.RUnlock()
	fake.updateSpaceQuotaMutex.RLock()
	defer fake.updateSpaceQuotaMutex.RUnlock()
	fake.updateStackLabelsByStackNameMutex.RLock()
	defer fake.updateStackLabelsByStackNameMutex.RUnlock()
	fake.updateUserPasswordMutex.RLock()
	defer fake.updateUserPasswordMutex.RUnlock()
	fake.updateUserProvidedServiceInstanceMutex.RLock()
	defer fake.updateUserProvidedServiceInstanceMutex.RUnlock()
	fake.upgradeManagedServiceInstanceMutex.RLock()
	defer fake.upgradeManagedServiceInstanceMutex.RUnlock()
	fake.uploadBitsPackageMutex.RLock()
	defer fake.uploadBitsPackageMutex.RUnlock()
	fake.uploadBuildpackMutex.RLock()
	defer fake.uploadBuildpackMutex.RUnlock()
	fake.uploadDropletMutex.RLock()
	defer fake.uploadDropletMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeActor) 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 _ v7.Actor = new(FakeActor)