// 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 {
	}
	ContinueDeploymentStub        func(string) (v7action.Warnings, error)
	continueDeploymentMutex       sync.RWMutex
	continueDeploymentArgsForCall []struct {
		arg1 string
	}
	continueDeploymentReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	continueDeploymentReturnsOnCall map[int]struct {
		result1 v7action.Warnings
		result2 error
	}
	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
	}
	CreateDeploymentStub        func(resources.Deployment) (string, v7action.Warnings, error)
	createDeploymentMutex       sync.RWMutex
	createDeploymentArgsForCall []struct {
		arg1 resources.Deployment
	}
	createDeploymentReturns struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}
	createDeploymentReturnsOnCall 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, map[string]*string) (resources.Route, v7action.Warnings, error)
	createRouteMutex       sync.RWMutex
	createRouteArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 string
		arg5 int
		arg6 map[string]*string
	}
	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
	}
	DeleteBuildpackByNameAndStackAndLifecycleStub        func(string, string, string) (v7action.Warnings, error)
	deleteBuildpackByNameAndStackAndLifecycleMutex       sync.RWMutex
	deleteBuildpackByNameAndStackAndLifecycleArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
	}
	deleteBuildpackByNameAndStackAndLifecycleReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	deleteBuildpackByNameAndStackAndLifecycleReturnsOnCall 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, bool) ([]v7action.ApplicationSummary, v7action.Warnings, error)
	getAppSummariesForSpaceMutex       sync.RWMutex
	getAppSummariesForSpaceArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 bool
	}
	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
	}
	GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub        func(string, string) ([]v7action.ProcessReadinessHealthCheck, v7action.Warnings, error)
	getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex       sync.RWMutex
	getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getApplicationProcessReadinessHealthChecksByNameAndSpaceReturns struct {
		result1 []v7action.ProcessReadinessHealthCheck
		result2 v7action.Warnings
		result3 error
	}
	getApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall map[int]struct {
		result1 []v7action.ProcessReadinessHealthCheck
		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
	}
	GetApplicationsByGUIDsStub        func([]string) ([]resources.Application, v7action.Warnings, error)
	getApplicationsByGUIDsMutex       sync.RWMutex
	getApplicationsByGUIDsArgsForCall []struct {
		arg1 []string
	}
	getApplicationsByGUIDsReturns struct {
		result1 []resources.Application
		result2 v7action.Warnings
		result3 error
	}
	getApplicationsByGUIDsReturnsOnCall map[int]struct {
		result1 []resources.Application
		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, string) (map[string]types.NullString, v7action.Warnings, error)
	getBuildpackLabelsMutex       sync.RWMutex
	getBuildpackLabelsArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 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, string) ([]resources.Buildpack, v7action.Warnings, error)
	getBuildpacksMutex       sync.RWMutex
	getBuildpacksArgsForCall []struct {
		arg1 string
		arg2 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
	}
	GetEnvironmentVariableGroupByRevisionStub        func(resources.Revision) (v7action.EnvironmentVariableGroup, bool, v7action.Warnings, error)
	getEnvironmentVariableGroupByRevisionMutex       sync.RWMutex
	getEnvironmentVariableGroupByRevisionArgsForCall []struct {
		arg1 resources.Revision
	}
	getEnvironmentVariableGroupByRevisionReturns struct {
		result1 v7action.EnvironmentVariableGroup
		result2 bool
		result3 v7action.Warnings
		result4 error
	}
	getEnvironmentVariableGroupByRevisionReturnsOnCall map[int]struct {
		result1 v7action.EnvironmentVariableGroup
		result2 bool
		result3 v7action.Warnings
		result4 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
	}
	GetInfoResponseStub        func() (v7action.Info, v7action.Warnings, error)
	getInfoResponseMutex       sync.RWMutex
	getInfoResponseArgsForCall []struct {
	}
	getInfoResponseReturns struct {
		result1 v7action.Info
		result2 v7action.Warnings
		result3 error
	}
	getInfoResponseReturnsOnCall map[int]struct {
		result1 v7action.Info
		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.Root, v7action.Warnings, error)
	getRootResponseMutex       sync.RWMutex
	getRootResponseArgsForCall []struct {
	}
	getRootResponseReturns struct {
		result1 v7action.Root
		result2 v7action.Warnings
		result3 error
	}
	getRootResponseReturnsOnCall map[int]struct {
		result1 v7action.Root
		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
	}
	PollStartForDeploymentStub        func(resources.Application, string, bool, func(string)) (v7action.Warnings, error)
	pollStartForDeploymentMutex       sync.RWMutex
	pollStartForDeploymentArgsForCall []struct {
		arg1 resources.Application
		arg2 string
		arg3 bool
		arg4 func(string)
	}
	pollStartForDeploymentReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	pollStartForDeploymentReturnsOnCall 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
	}
	UpdateBuildpackByNameAndStackAndLifecycleStub        func(string, string, string, resources.Buildpack) (resources.Buildpack, v7action.Warnings, error)
	updateBuildpackByNameAndStackAndLifecycleMutex       sync.RWMutex
	updateBuildpackByNameAndStackAndLifecycleArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 resources.Buildpack
	}
	updateBuildpackByNameAndStackAndLifecycleReturns struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	updateBuildpackByNameAndStackAndLifecycleReturnsOnCall map[int]struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}
	UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleStub        func(string, string, string, map[string]types.NullString) (v7action.Warnings, error)
	updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex       sync.RWMutex
	updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall []struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 map[string]types.NullString
	}
	updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns struct {
		result1 v7action.Warnings
		result2 error
	}
	updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall 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
	}
	UpdateRouteStub        func(string, map[string]*string) (resources.Route, v7action.Warnings, error)
	updateRouteMutex       sync.RWMutex
	updateRouteArgsForCall []struct {
		arg1 string
		arg2 map[string]*string
	}
	updateRouteReturns struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}
	updateRouteReturnsOnCall map[int]struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 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})
	stub := fake.ApplyOrganizationQuotaByNameStub
	fakeReturns := fake.applyOrganizationQuotaByNameReturns
	fake.recordInvocation("ApplyOrganizationQuotaByName", []interface{}{arg1, arg2})
	fake.applyOrganizationQuotaByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.ApplySpaceQuotaByNameStub
	fakeReturns := fake.applySpaceQuotaByNameReturns
	fake.recordInvocation("ApplySpaceQuotaByName", []interface{}{arg1, arg2, arg3})
	fake.applySpaceQuotaByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.AssignIsolationSegmentToSpaceByNameAndSpaceStub
	fakeReturns := fake.assignIsolationSegmentToSpaceByNameAndSpaceReturns
	fake.recordInvocation("AssignIsolationSegmentToSpaceByNameAndSpace", []interface{}{arg1, arg2})
	fake.assignIsolationSegmentToSpaceByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.AuthenticateStub
	fakeReturns := fake.authenticateReturns
	fake.recordInvocation("Authenticate", []interface{}{arg1, arg2, arg3})
	fake.authenticateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	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})
	stub := fake.BindSecurityGroupToSpacesStub
	fakeReturns := fake.bindSecurityGroupToSpacesReturns
	fake.recordInvocation("BindSecurityGroupToSpaces", []interface{}{arg1, arg2Copy, arg3})
	fake.bindSecurityGroupToSpacesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CancelDeploymentStub
	fakeReturns := fake.cancelDeploymentReturns
	fake.recordInvocation("CancelDeployment", []interface{}{arg1})
	fake.cancelDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CheckRouteStub
	fakeReturns := fake.checkRouteReturns
	fake.recordInvocation("CheckRoute", []interface{}{arg1, arg2, arg3, arg4})
	fake.checkRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.ClearTargetStub
	fake.recordInvocation("ClearTarget", []interface{}{})
	fake.clearTargetMutex.Unlock()
	if stub != 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) ContinueDeployment(arg1 string) (v7action.Warnings, error) {
	fake.continueDeploymentMutex.Lock()
	ret, specificReturn := fake.continueDeploymentReturnsOnCall[len(fake.continueDeploymentArgsForCall)]
	fake.continueDeploymentArgsForCall = append(fake.continueDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ContinueDeploymentStub
	fakeReturns := fake.continueDeploymentReturns
	fake.recordInvocation("ContinueDeployment", []interface{}{arg1})
	fake.continueDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) ContinueDeploymentCallCount() int {
	fake.continueDeploymentMutex.RLock()
	defer fake.continueDeploymentMutex.RUnlock()
	return len(fake.continueDeploymentArgsForCall)
}

func (fake *FakeActor) ContinueDeploymentCalls(stub func(string) (v7action.Warnings, error)) {
	fake.continueDeploymentMutex.Lock()
	defer fake.continueDeploymentMutex.Unlock()
	fake.ContinueDeploymentStub = stub
}

func (fake *FakeActor) ContinueDeploymentArgsForCall(i int) string {
	fake.continueDeploymentMutex.RLock()
	defer fake.continueDeploymentMutex.RUnlock()
	argsForCall := fake.continueDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) ContinueDeploymentReturns(result1 v7action.Warnings, result2 error) {
	fake.continueDeploymentMutex.Lock()
	defer fake.continueDeploymentMutex.Unlock()
	fake.ContinueDeploymentStub = nil
	fake.continueDeploymentReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) ContinueDeploymentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.continueDeploymentMutex.Lock()
	defer fake.continueDeploymentMutex.Unlock()
	fake.ContinueDeploymentStub = nil
	if fake.continueDeploymentReturnsOnCall == nil {
		fake.continueDeploymentReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.continueDeploymentReturnsOnCall[i] = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

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})
	stub := fake.CopyPackageStub
	fakeReturns := fake.copyPackageReturns
	fake.recordInvocation("CopyPackage", []interface{}{arg1, arg2})
	fake.copyPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateAndUploadBitsPackageByApplicationNameAndSpaceStub
	fakeReturns := fake.createAndUploadBitsPackageByApplicationNameAndSpaceReturns
	fake.recordInvocation("CreateAndUploadBitsPackageByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.createAndUploadBitsPackageByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateApplicationDropletStub
	fakeReturns := fake.createApplicationDropletReturns
	fake.recordInvocation("CreateApplicationDroplet", []interface{}{arg1})
	fake.createApplicationDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateApplicationInSpaceStub
	fakeReturns := fake.createApplicationInSpaceReturns
	fake.recordInvocation("CreateApplicationInSpace", []interface{}{arg1, arg2})
	fake.createApplicationInSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateBitsPackageByApplicationStub
	fakeReturns := fake.createBitsPackageByApplicationReturns
	fake.recordInvocation("CreateBitsPackageByApplication", []interface{}{arg1})
	fake.createBitsPackageByApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateBuildpackStub
	fakeReturns := fake.createBuildpackReturns
	fake.recordInvocation("CreateBuildpack", []interface{}{arg1})
	fake.createBuildpackMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) CreateDeployment(arg1 resources.Deployment) (string, v7action.Warnings, error) {
	fake.createDeploymentMutex.Lock()
	ret, specificReturn := fake.createDeploymentReturnsOnCall[len(fake.createDeploymentArgsForCall)]
	fake.createDeploymentArgsForCall = append(fake.createDeploymentArgsForCall, struct {
		arg1 resources.Deployment
	}{arg1})
	stub := fake.CreateDeploymentStub
	fakeReturns := fake.createDeploymentReturns
	fake.recordInvocation("CreateDeployment", []interface{}{arg1})
	fake.createDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) CreateDeploymentCallCount() int {
	fake.createDeploymentMutex.RLock()
	defer fake.createDeploymentMutex.RUnlock()
	return len(fake.createDeploymentArgsForCall)
}

func (fake *FakeActor) CreateDeploymentCalls(stub func(resources.Deployment) (string, v7action.Warnings, error)) {
	fake.createDeploymentMutex.Lock()
	defer fake.createDeploymentMutex.Unlock()
	fake.CreateDeploymentStub = stub
}

func (fake *FakeActor) CreateDeploymentArgsForCall(i int) resources.Deployment {
	fake.createDeploymentMutex.RLock()
	defer fake.createDeploymentMutex.RUnlock()
	argsForCall := fake.createDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) CreateDeploymentReturns(result1 string, result2 v7action.Warnings, result3 error) {
	fake.createDeploymentMutex.Lock()
	defer fake.createDeploymentMutex.Unlock()
	fake.CreateDeploymentStub = nil
	fake.createDeploymentReturns = struct {
		result1 string
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) CreateDeploymentReturnsOnCall(i int, result1 string, result2 v7action.Warnings, result3 error) {
	fake.createDeploymentMutex.Lock()
	defer fake.createDeploymentMutex.Unlock()
	fake.CreateDeploymentStub = nil
	if fake.createDeploymentReturnsOnCall == nil {
		fake.createDeploymentReturnsOnCall = make(map[int]struct {
			result1 string
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.createDeploymentReturnsOnCall[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})
	stub := fake.CreateDockerPackageByApplicationStub
	fakeReturns := fake.createDockerPackageByApplicationReturns
	fake.recordInvocation("CreateDockerPackageByApplication", []interface{}{arg1, arg2})
	fake.createDockerPackageByApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateDockerPackageByApplicationNameAndSpaceStub
	fakeReturns := fake.createDockerPackageByApplicationNameAndSpaceReturns
	fake.recordInvocation("CreateDockerPackageByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.createDockerPackageByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateIsolationSegmentByNameStub
	fakeReturns := fake.createIsolationSegmentByNameReturns
	fake.recordInvocation("CreateIsolationSegmentByName", []interface{}{arg1})
	fake.createIsolationSegmentByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateManagedServiceInstanceStub
	fakeReturns := fake.createManagedServiceInstanceReturns
	fake.recordInvocation("CreateManagedServiceInstance", []interface{}{arg1})
	fake.createManagedServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateOrgRoleStub
	fakeReturns := fake.createOrgRoleReturns
	fake.recordInvocation("CreateOrgRole", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.createOrgRoleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateOrganizationStub
	fakeReturns := fake.createOrganizationReturns
	fake.recordInvocation("CreateOrganization", []interface{}{arg1})
	fake.createOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateOrganizationQuotaStub
	fakeReturns := fake.createOrganizationQuotaReturns
	fake.recordInvocation("CreateOrganizationQuota", []interface{}{arg1, arg2})
	fake.createOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreatePrivateDomainStub
	fakeReturns := fake.createPrivateDomainReturns
	fake.recordInvocation("CreatePrivateDomain", []interface{}{arg1, arg2})
	fake.createPrivateDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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, arg6 map[string]*string) (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
		arg6 map[string]*string
	}{arg1, arg2, arg3, arg4, arg5, arg6})
	stub := fake.CreateRouteStub
	fakeReturns := fake.createRouteReturns
	fake.recordInvocation("CreateRoute", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.createRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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, map[string]*string) (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, map[string]*string) {
	fake.createRouteMutex.RLock()
	defer fake.createRouteMutex.RUnlock()
	argsForCall := fake.createRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5, argsForCall.arg6
}

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})
	stub := fake.CreateRouteBindingStub
	fakeReturns := fake.createRouteBindingReturns
	fake.recordInvocation("CreateRouteBinding", []interface{}{arg1})
	fake.createRouteBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateSecurityGroupStub
	fakeReturns := fake.createSecurityGroupReturns
	fake.recordInvocation("CreateSecurityGroup", []interface{}{arg1, arg2})
	fake.createSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateServiceAppBindingStub
	fakeReturns := fake.createServiceAppBindingReturns
	fake.recordInvocation("CreateServiceAppBinding", []interface{}{arg1})
	fake.createServiceAppBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateServiceBrokerStub
	fakeReturns := fake.createServiceBrokerReturns
	fake.recordInvocation("CreateServiceBroker", []interface{}{arg1})
	fake.createServiceBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateServiceKeyStub
	fakeReturns := fake.createServiceKeyReturns
	fake.recordInvocation("CreateServiceKey", []interface{}{arg1})
	fake.createServiceKeyMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateSharedDomainStub
	fakeReturns := fake.createSharedDomainReturns
	fake.recordInvocation("CreateSharedDomain", []interface{}{arg1, arg2, arg3})
	fake.createSharedDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateSpaceStub
	fakeReturns := fake.createSpaceReturns
	fake.recordInvocation("CreateSpace", []interface{}{arg1, arg2})
	fake.createSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateSpaceQuotaStub
	fakeReturns := fake.createSpaceQuotaReturns
	fake.recordInvocation("CreateSpaceQuota", []interface{}{arg1, arg2, arg3})
	fake.createSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateSpaceRoleStub
	fakeReturns := fake.createSpaceRoleReturns
	fake.recordInvocation("CreateSpaceRole", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.createSpaceRoleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.CreateUserStub
	fakeReturns := fake.createUserReturns
	fake.recordInvocation("CreateUser", []interface{}{arg1, arg2, arg3})
	fake.createUserMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.CreateUserProvidedServiceInstanceStub
	fakeReturns := fake.createUserProvidedServiceInstanceReturns
	fake.recordInvocation("CreateUserProvidedServiceInstance", []interface{}{arg1})
	fake.createUserProvidedServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteApplicationByNameAndSpaceStub
	fakeReturns := fake.deleteApplicationByNameAndSpaceReturns
	fake.recordInvocation("DeleteApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.deleteApplicationByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) DeleteBuildpackByNameAndStackAndLifecycle(arg1 string, arg2 string, arg3 string) (v7action.Warnings, error) {
	fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Lock()
	ret, specificReturn := fake.deleteBuildpackByNameAndStackAndLifecycleReturnsOnCall[len(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall)]
	fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall = append(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.DeleteBuildpackByNameAndStackAndLifecycleStub
	fakeReturns := fake.deleteBuildpackByNameAndStackAndLifecycleReturns
	fake.recordInvocation("DeleteBuildpackByNameAndStackAndLifecycle", []interface{}{arg1, arg2, arg3})
	fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleCallCount() int {
	fake.deleteBuildpackByNameAndStackAndLifecycleMutex.RLock()
	defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.RUnlock()
	return len(fake.deleteBuildpackByNameAndStackAndLifecycleArgsForCall)
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleCalls(stub func(string, string, string) (v7action.Warnings, error)) {
	fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Lock()
	defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	fake.DeleteBuildpackByNameAndStackAndLifecycleStub = stub
}

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

func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleReturns(result1 v7action.Warnings, result2 error) {
	fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Lock()
	defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	fake.DeleteBuildpackByNameAndStackAndLifecycleStub = nil
	fake.deleteBuildpackByNameAndStackAndLifecycleReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) DeleteBuildpackByNameAndStackAndLifecycleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Lock()
	defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	fake.DeleteBuildpackByNameAndStackAndLifecycleStub = nil
	if fake.deleteBuildpackByNameAndStackAndLifecycleReturnsOnCall == nil {
		fake.deleteBuildpackByNameAndStackAndLifecycleReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.deleteBuildpackByNameAndStackAndLifecycleReturnsOnCall[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})
	stub := fake.DeleteDomainStub
	fakeReturns := fake.deleteDomainReturns
	fake.recordInvocation("DeleteDomain", []interface{}{arg1})
	fake.deleteDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteInstanceByApplicationNameSpaceProcessTypeAndIndexStub
	fakeReturns := fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexReturns
	fake.recordInvocation("DeleteInstanceByApplicationNameSpaceProcessTypeAndIndex", []interface{}{arg1, arg2, arg3, arg4})
	fake.deleteInstanceByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteIsolationSegmentByNameStub
	fakeReturns := fake.deleteIsolationSegmentByNameReturns
	fake.recordInvocation("DeleteIsolationSegmentByName", []interface{}{arg1})
	fake.deleteIsolationSegmentByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteIsolationSegmentOrganizationByNameStub
	fakeReturns := fake.deleteIsolationSegmentOrganizationByNameReturns
	fake.recordInvocation("DeleteIsolationSegmentOrganizationByName", []interface{}{arg1, arg2})
	fake.deleteIsolationSegmentOrganizationByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteOrgRoleStub
	fakeReturns := fake.deleteOrgRoleReturns
	fake.recordInvocation("DeleteOrgRole", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.deleteOrgRoleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteOrganizationStub
	fakeReturns := fake.deleteOrganizationReturns
	fake.recordInvocation("DeleteOrganization", []interface{}{arg1})
	fake.deleteOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteOrganizationQuotaStub
	fakeReturns := fake.deleteOrganizationQuotaReturns
	fake.recordInvocation("DeleteOrganizationQuota", []interface{}{arg1})
	fake.deleteOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteOrphanedRoutesStub
	fakeReturns := fake.deleteOrphanedRoutesReturns
	fake.recordInvocation("DeleteOrphanedRoutes", []interface{}{arg1})
	fake.deleteOrphanedRoutesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteRouteStub
	fakeReturns := fake.deleteRouteReturns
	fake.recordInvocation("DeleteRoute", []interface{}{arg1, arg2, arg3, arg4})
	fake.deleteRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteRouteBindingStub
	fakeReturns := fake.deleteRouteBindingReturns
	fake.recordInvocation("DeleteRouteBinding", []interface{}{arg1})
	fake.deleteRouteBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.DeleteSecurityGroupStub
	fakeReturns := fake.deleteSecurityGroupReturns
	fake.recordInvocation("DeleteSecurityGroup", []interface{}{arg1})
	fake.deleteSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteServiceAppBindingStub
	fakeReturns := fake.deleteServiceAppBindingReturns
	fake.recordInvocation("DeleteServiceAppBinding", []interface{}{arg1})
	fake.deleteServiceAppBindingMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.DeleteServiceBrokerStub
	fakeReturns := fake.deleteServiceBrokerReturns
	fake.recordInvocation("DeleteServiceBroker", []interface{}{arg1})
	fake.deleteServiceBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteServiceInstanceStub
	fakeReturns := fake.deleteServiceInstanceReturns
	fake.recordInvocation("DeleteServiceInstance", []interface{}{arg1, arg2})
	fake.deleteServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.DeleteServiceKeyByServiceInstanceAndNameStub
	fakeReturns := fake.deleteServiceKeyByServiceInstanceAndNameReturns
	fake.recordInvocation("DeleteServiceKeyByServiceInstanceAndName", []interface{}{arg1, arg2, arg3})
	fake.deleteServiceKeyByServiceInstanceAndNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.DeleteSpaceByNameAndOrganizationNameStub
	fakeReturns := fake.deleteSpaceByNameAndOrganizationNameReturns
	fake.recordInvocation("DeleteSpaceByNameAndOrganizationName", []interface{}{arg1, arg2})
	fake.deleteSpaceByNameAndOrganizationNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteSpaceQuotaByNameStub
	fakeReturns := fake.deleteSpaceQuotaByNameReturns
	fake.recordInvocation("DeleteSpaceQuotaByName", []interface{}{arg1, arg2})
	fake.deleteSpaceQuotaByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteSpaceRoleStub
	fakeReturns := fake.deleteSpaceRoleReturns
	fake.recordInvocation("DeleteSpaceRole", []interface{}{arg1, arg2, arg3, arg4, arg5})
	fake.deleteSpaceRoleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DeleteUserStub
	fakeReturns := fake.deleteUserReturns
	fake.recordInvocation("DeleteUser", []interface{}{arg1})
	fake.deleteUserMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DiffSpaceManifestStub
	fakeReturns := fake.diffSpaceManifestReturns
	fake.recordInvocation("DiffSpaceManifest", []interface{}{arg1, arg2Copy})
	fake.diffSpaceManifestMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.DisableFeatureFlagStub
	fakeReturns := fake.disableFeatureFlagReturns
	fake.recordInvocation("DisableFeatureFlag", []interface{}{arg1})
	fake.disableFeatureFlagMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.DisableServiceAccessStub
	fakeReturns := fake.disableServiceAccessReturns
	fake.recordInvocation("DisableServiceAccess", []interface{}{arg1, arg2, arg3, arg4})
	fake.disableServiceAccessMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.DownloadCurrentDropletByAppNameStub
	fakeReturns := fake.downloadCurrentDropletByAppNameReturns
	fake.recordInvocation("DownloadCurrentDropletByAppName", []interface{}{arg1, arg2})
	fake.downloadCurrentDropletByAppNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	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})
	stub := fake.DownloadDropletByGUIDAndAppNameStub
	fakeReturns := fake.downloadDropletByGUIDAndAppNameReturns
	fake.recordInvocation("DownloadDropletByGUIDAndAppName", []interface{}{arg1, arg2, arg3})
	fake.downloadDropletByGUIDAndAppNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.EnableFeatureFlagStub
	fakeReturns := fake.enableFeatureFlagReturns
	fake.recordInvocation("EnableFeatureFlag", []interface{}{arg1})
	fake.enableFeatureFlagMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.EnableServiceAccessStub
	fakeReturns := fake.enableServiceAccessReturns
	fake.recordInvocation("EnableServiceAccess", []interface{}{arg1, arg2, arg3, arg4})
	fake.enableServiceAccessMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.EntitleIsolationSegmentToOrganizationByNameStub
	fakeReturns := fake.entitleIsolationSegmentToOrganizationByNameReturns
	fake.recordInvocation("EntitleIsolationSegmentToOrganizationByName", []interface{}{arg1, arg2})
	fake.entitleIsolationSegmentToOrganizationByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetAppFeatureStub
	fakeReturns := fake.getAppFeatureReturns
	fake.recordInvocation("GetAppFeature", []interface{}{arg1, arg2})
	fake.getAppFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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, arg3 bool) ([]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
		arg3 bool
	}{arg1, arg2, arg3})
	stub := fake.GetAppSummariesForSpaceStub
	fakeReturns := fake.getAppSummariesForSpaceReturns
	fake.recordInvocation("GetAppSummariesForSpace", []interface{}{arg1, arg2, arg3})
	fake.getAppSummariesForSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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, bool) ([]v7action.ApplicationSummary, v7action.Warnings, error)) {
	fake.getAppSummariesForSpaceMutex.Lock()
	defer fake.getAppSummariesForSpaceMutex.Unlock()
	fake.GetAppSummariesForSpaceStub = stub
}

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

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})
	stub := fake.GetApplicationByNameAndSpaceStub
	fakeReturns := fake.getApplicationByNameAndSpaceReturns
	fake.recordInvocation("GetApplicationByNameAndSpace", []interface{}{arg1, arg2})
	fake.getApplicationByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationDropletsStub
	fakeReturns := fake.getApplicationDropletsReturns
	fake.recordInvocation("GetApplicationDroplets", []interface{}{arg1, arg2})
	fake.getApplicationDropletsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationLabelsStub
	fakeReturns := fake.getApplicationLabelsReturns
	fake.recordInvocation("GetApplicationLabels", []interface{}{arg1, arg2})
	fake.getApplicationLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationMapForRouteStub
	fakeReturns := fake.getApplicationMapForRouteReturns
	fake.recordInvocation("GetApplicationMapForRoute", []interface{}{arg1})
	fake.getApplicationMapForRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationPackagesStub
	fakeReturns := fake.getApplicationPackagesReturns
	fake.recordInvocation("GetApplicationPackages", []interface{}{arg1, arg2})
	fake.getApplicationPackagesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationProcessHealthChecksByNameAndSpaceStub
	fakeReturns := fake.getApplicationProcessHealthChecksByNameAndSpaceReturns
	fake.recordInvocation("GetApplicationProcessHealthChecksByNameAndSpace", []interface{}{arg1, arg2})
	fake.getApplicationProcessHealthChecksByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationProcessReadinessHealthChecksByNameAndSpace(arg1 string, arg2 string) ([]v7action.ProcessReadinessHealthCheck, v7action.Warnings, error) {
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Lock()
	ret, specificReturn := fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall[len(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall)]
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall = append(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub
	fakeReturns := fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturns
	fake.recordInvocation("GetApplicationProcessReadinessHealthChecksByNameAndSpace", []interface{}{arg1, arg2})
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceCallCount() int {
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RLock()
	defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RUnlock()
	return len(fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceArgsForCall)
}

func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceCalls(stub func(string, string) ([]v7action.ProcessReadinessHealthCheck, v7action.Warnings, error)) {
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Lock()
	defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Unlock()
	fake.GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub = stub
}

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

func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceReturns(result1 []v7action.ProcessReadinessHealthCheck, result2 v7action.Warnings, result3 error) {
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Lock()
	defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Unlock()
	fake.GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub = nil
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturns = struct {
		result1 []v7action.ProcessReadinessHealthCheck
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall(i int, result1 []v7action.ProcessReadinessHealthCheck, result2 v7action.Warnings, result3 error) {
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Lock()
	defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.Unlock()
	fake.GetApplicationProcessReadinessHealthChecksByNameAndSpaceStub = nil
	if fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall == nil {
		fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall = make(map[int]struct {
			result1 []v7action.ProcessReadinessHealthCheck
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceReturnsOnCall[i] = struct {
		result1 []v7action.ProcessReadinessHealthCheck
		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})
	stub := fake.GetApplicationRevisionsDeployedStub
	fakeReturns := fake.getApplicationRevisionsDeployedReturns
	fake.recordInvocation("GetApplicationRevisionsDeployed", []interface{}{arg1})
	fake.getApplicationRevisionsDeployedMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationRoutesStub
	fakeReturns := fake.getApplicationRoutesReturns
	fake.recordInvocation("GetApplicationRoutes", []interface{}{arg1})
	fake.getApplicationRoutesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetApplicationTasksStub
	fakeReturns := fake.getApplicationTasksReturns
	fake.recordInvocation("GetApplicationTasks", []interface{}{arg1, arg2})
	fake.getApplicationTasksMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetApplicationsByGUIDs(arg1 []string) ([]resources.Application, v7action.Warnings, error) {
	var arg1Copy []string
	if arg1 != nil {
		arg1Copy = make([]string, len(arg1))
		copy(arg1Copy, arg1)
	}
	fake.getApplicationsByGUIDsMutex.Lock()
	ret, specificReturn := fake.getApplicationsByGUIDsReturnsOnCall[len(fake.getApplicationsByGUIDsArgsForCall)]
	fake.getApplicationsByGUIDsArgsForCall = append(fake.getApplicationsByGUIDsArgsForCall, struct {
		arg1 []string
	}{arg1Copy})
	stub := fake.GetApplicationsByGUIDsStub
	fakeReturns := fake.getApplicationsByGUIDsReturns
	fake.recordInvocation("GetApplicationsByGUIDs", []interface{}{arg1Copy})
	fake.getApplicationsByGUIDsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetApplicationsByGUIDsCallCount() int {
	fake.getApplicationsByGUIDsMutex.RLock()
	defer fake.getApplicationsByGUIDsMutex.RUnlock()
	return len(fake.getApplicationsByGUIDsArgsForCall)
}

func (fake *FakeActor) GetApplicationsByGUIDsCalls(stub func([]string) ([]resources.Application, v7action.Warnings, error)) {
	fake.getApplicationsByGUIDsMutex.Lock()
	defer fake.getApplicationsByGUIDsMutex.Unlock()
	fake.GetApplicationsByGUIDsStub = stub
}

func (fake *FakeActor) GetApplicationsByGUIDsArgsForCall(i int) []string {
	fake.getApplicationsByGUIDsMutex.RLock()
	defer fake.getApplicationsByGUIDsMutex.RUnlock()
	argsForCall := fake.getApplicationsByGUIDsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetApplicationsByGUIDsReturns(result1 []resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationsByGUIDsMutex.Lock()
	defer fake.getApplicationsByGUIDsMutex.Unlock()
	fake.GetApplicationsByGUIDsStub = nil
	fake.getApplicationsByGUIDsReturns = struct {
		result1 []resources.Application
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetApplicationsByGUIDsReturnsOnCall(i int, result1 []resources.Application, result2 v7action.Warnings, result3 error) {
	fake.getApplicationsByGUIDsMutex.Lock()
	defer fake.getApplicationsByGUIDsMutex.Unlock()
	fake.GetApplicationsByGUIDsStub = nil
	if fake.getApplicationsByGUIDsReturnsOnCall == nil {
		fake.getApplicationsByGUIDsReturnsOnCall = make(map[int]struct {
			result1 []resources.Application
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getApplicationsByGUIDsReturnsOnCall[i] = struct {
		result1 []resources.Application
		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})
	stub := fake.GetApplicationsByNamesAndSpaceStub
	fakeReturns := fake.getApplicationsByNamesAndSpaceReturns
	fake.recordInvocation("GetApplicationsByNamesAndSpace", []interface{}{arg1Copy, arg2})
	fake.getApplicationsByNamesAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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, arg3 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
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.GetBuildpackLabelsStub
	fakeReturns := fake.getBuildpackLabelsReturns
	fake.recordInvocation("GetBuildpackLabels", []interface{}{arg1, arg2, arg3})
	fake.getBuildpackLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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, 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, string) {
	fake.getBuildpackLabelsMutex.RLock()
	defer fake.getBuildpackLabelsMutex.RUnlock()
	argsForCall := fake.getBuildpackLabelsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

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, arg2 string) ([]resources.Buildpack, v7action.Warnings, error) {
	fake.getBuildpacksMutex.Lock()
	ret, specificReturn := fake.getBuildpacksReturnsOnCall[len(fake.getBuildpacksArgsForCall)]
	fake.getBuildpacksArgsForCall = append(fake.getBuildpacksArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetBuildpacksStub
	fakeReturns := fake.getBuildpacksReturns
	fake.recordInvocation("GetBuildpacks", []interface{}{arg1, arg2})
	fake.getBuildpacksMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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, string) ([]resources.Buildpack, v7action.Warnings, error)) {
	fake.getBuildpacksMutex.Lock()
	defer fake.getBuildpacksMutex.Unlock()
	fake.GetBuildpacksStub = stub
}

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

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 {
	}{})
	stub := fake.GetCurrentUserStub
	fakeReturns := fake.getCurrentUserReturns
	fake.recordInvocation("GetCurrentUser", []interface{}{})
	fake.getCurrentUserMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetDefaultDomainStub
	fakeReturns := fake.getDefaultDomainReturns
	fake.recordInvocation("GetDefaultDomain", []interface{}{arg1})
	fake.getDefaultDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetDetailedAppSummaryStub
	fakeReturns := fake.getDetailedAppSummaryReturns
	fake.recordInvocation("GetDetailedAppSummary", []interface{}{arg1, arg2, arg3})
	fake.getDetailedAppSummaryMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetDomainStub
	fakeReturns := fake.getDomainReturns
	fake.recordInvocation("GetDomain", []interface{}{arg1})
	fake.getDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetDomainByNameStub
	fakeReturns := fake.getDomainByNameReturns
	fake.recordInvocation("GetDomainByName", []interface{}{arg1})
	fake.getDomainByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetDomainLabelsStub
	fakeReturns := fake.getDomainLabelsReturns
	fake.recordInvocation("GetDomainLabels", []interface{}{arg1})
	fake.getDomainLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetEffectiveIsolationSegmentBySpaceStub
	fakeReturns := fake.getEffectiveIsolationSegmentBySpaceReturns
	fake.recordInvocation("GetEffectiveIsolationSegmentBySpace", []interface{}{arg1, arg2})
	fake.getEffectiveIsolationSegmentBySpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetEnvironmentVariableGroupStub
	fakeReturns := fake.getEnvironmentVariableGroupReturns
	fake.recordInvocation("GetEnvironmentVariableGroup", []interface{}{arg1})
	fake.getEnvironmentVariableGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetEnvironmentVariableGroupByRevision(arg1 resources.Revision) (v7action.EnvironmentVariableGroup, bool, v7action.Warnings, error) {
	fake.getEnvironmentVariableGroupByRevisionMutex.Lock()
	ret, specificReturn := fake.getEnvironmentVariableGroupByRevisionReturnsOnCall[len(fake.getEnvironmentVariableGroupByRevisionArgsForCall)]
	fake.getEnvironmentVariableGroupByRevisionArgsForCall = append(fake.getEnvironmentVariableGroupByRevisionArgsForCall, struct {
		arg1 resources.Revision
	}{arg1})
	stub := fake.GetEnvironmentVariableGroupByRevisionStub
	fakeReturns := fake.getEnvironmentVariableGroupByRevisionReturns
	fake.recordInvocation("GetEnvironmentVariableGroupByRevision", []interface{}{arg1})
	fake.getEnvironmentVariableGroupByRevisionMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3, fakeReturns.result4
}

func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionCallCount() int {
	fake.getEnvironmentVariableGroupByRevisionMutex.RLock()
	defer fake.getEnvironmentVariableGroupByRevisionMutex.RUnlock()
	return len(fake.getEnvironmentVariableGroupByRevisionArgsForCall)
}

func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionCalls(stub func(resources.Revision) (v7action.EnvironmentVariableGroup, bool, v7action.Warnings, error)) {
	fake.getEnvironmentVariableGroupByRevisionMutex.Lock()
	defer fake.getEnvironmentVariableGroupByRevisionMutex.Unlock()
	fake.GetEnvironmentVariableGroupByRevisionStub = stub
}

func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionArgsForCall(i int) resources.Revision {
	fake.getEnvironmentVariableGroupByRevisionMutex.RLock()
	defer fake.getEnvironmentVariableGroupByRevisionMutex.RUnlock()
	argsForCall := fake.getEnvironmentVariableGroupByRevisionArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionReturns(result1 v7action.EnvironmentVariableGroup, result2 bool, result3 v7action.Warnings, result4 error) {
	fake.getEnvironmentVariableGroupByRevisionMutex.Lock()
	defer fake.getEnvironmentVariableGroupByRevisionMutex.Unlock()
	fake.GetEnvironmentVariableGroupByRevisionStub = nil
	fake.getEnvironmentVariableGroupByRevisionReturns = struct {
		result1 v7action.EnvironmentVariableGroup
		result2 bool
		result3 v7action.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

func (fake *FakeActor) GetEnvironmentVariableGroupByRevisionReturnsOnCall(i int, result1 v7action.EnvironmentVariableGroup, result2 bool, result3 v7action.Warnings, result4 error) {
	fake.getEnvironmentVariableGroupByRevisionMutex.Lock()
	defer fake.getEnvironmentVariableGroupByRevisionMutex.Unlock()
	fake.GetEnvironmentVariableGroupByRevisionStub = nil
	if fake.getEnvironmentVariableGroupByRevisionReturnsOnCall == nil {
		fake.getEnvironmentVariableGroupByRevisionReturnsOnCall = make(map[int]struct {
			result1 v7action.EnvironmentVariableGroup
			result2 bool
			result3 v7action.Warnings
			result4 error
		})
	}
	fake.getEnvironmentVariableGroupByRevisionReturnsOnCall[i] = struct {
		result1 v7action.EnvironmentVariableGroup
		result2 bool
		result3 v7action.Warnings
		result4 error
	}{result1, result2, result3, result4}
}

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})
	stub := fake.GetEnvironmentVariablesByApplicationNameAndSpaceStub
	fakeReturns := fake.getEnvironmentVariablesByApplicationNameAndSpaceReturns
	fake.recordInvocation("GetEnvironmentVariablesByApplicationNameAndSpace", []interface{}{arg1, arg2})
	fake.getEnvironmentVariablesByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetFeatureFlagByNameStub
	fakeReturns := fake.getFeatureFlagByNameReturns
	fake.recordInvocation("GetFeatureFlagByName", []interface{}{arg1})
	fake.getFeatureFlagByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetFeatureFlagsStub
	fakeReturns := fake.getFeatureFlagsReturns
	fake.recordInvocation("GetFeatureFlags", []interface{}{})
	fake.getFeatureFlagsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetGlobalRunningSecurityGroupsStub
	fakeReturns := fake.getGlobalRunningSecurityGroupsReturns
	fake.recordInvocation("GetGlobalRunningSecurityGroups", []interface{}{})
	fake.getGlobalRunningSecurityGroupsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetGlobalStagingSecurityGroupsStub
	fakeReturns := fake.getGlobalStagingSecurityGroupsReturns
	fake.recordInvocation("GetGlobalStagingSecurityGroups", []interface{}{})
	fake.getGlobalStagingSecurityGroupsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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) GetInfoResponse() (v7action.Info, v7action.Warnings, error) {
	fake.getInfoResponseMutex.Lock()
	ret, specificReturn := fake.getInfoResponseReturnsOnCall[len(fake.getInfoResponseArgsForCall)]
	fake.getInfoResponseArgsForCall = append(fake.getInfoResponseArgsForCall, struct {
	}{})
	stub := fake.GetInfoResponseStub
	fakeReturns := fake.getInfoResponseReturns
	fake.recordInvocation("GetInfoResponse", []interface{}{})
	fake.getInfoResponseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) GetInfoResponseCallCount() int {
	fake.getInfoResponseMutex.RLock()
	defer fake.getInfoResponseMutex.RUnlock()
	return len(fake.getInfoResponseArgsForCall)
}

func (fake *FakeActor) GetInfoResponseCalls(stub func() (v7action.Info, v7action.Warnings, error)) {
	fake.getInfoResponseMutex.Lock()
	defer fake.getInfoResponseMutex.Unlock()
	fake.GetInfoResponseStub = stub
}

func (fake *FakeActor) GetInfoResponseReturns(result1 v7action.Info, result2 v7action.Warnings, result3 error) {
	fake.getInfoResponseMutex.Lock()
	defer fake.getInfoResponseMutex.Unlock()
	fake.GetInfoResponseStub = nil
	fake.getInfoResponseReturns = struct {
		result1 v7action.Info
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) GetInfoResponseReturnsOnCall(i int, result1 v7action.Info, result2 v7action.Warnings, result3 error) {
	fake.getInfoResponseMutex.Lock()
	defer fake.getInfoResponseMutex.Unlock()
	fake.GetInfoResponseStub = nil
	if fake.getInfoResponseReturnsOnCall == nil {
		fake.getInfoResponseReturnsOnCall = make(map[int]struct {
			result1 v7action.Info
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getInfoResponseReturnsOnCall[i] = struct {
		result1 v7action.Info
		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})
	stub := fake.GetIsolationSegmentByNameStub
	fakeReturns := fake.getIsolationSegmentByNameReturns
	fake.recordInvocation("GetIsolationSegmentByName", []interface{}{arg1})
	fake.getIsolationSegmentByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetIsolationSegmentSummariesStub
	fakeReturns := fake.getIsolationSegmentSummariesReturns
	fake.recordInvocation("GetIsolationSegmentSummaries", []interface{}{})
	fake.getIsolationSegmentSummariesMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetIsolationSegmentsByOrganizationStub
	fakeReturns := fake.getIsolationSegmentsByOrganizationReturns
	fake.recordInvocation("GetIsolationSegmentsByOrganization", []interface{}{arg1})
	fake.getIsolationSegmentsByOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetLatestActiveDeploymentForAppStub
	fakeReturns := fake.getLatestActiveDeploymentForAppReturns
	fake.recordInvocation("GetLatestActiveDeploymentForApp", []interface{}{arg1})
	fake.getLatestActiveDeploymentForAppMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetLoginPromptsStub
	fakeReturns := fake.getLoginPromptsReturns
	fake.recordInvocation("GetLoginPrompts", []interface{}{})
	fake.getLoginPromptsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetNewestReadyPackageForApplicationStub
	fakeReturns := fake.getNewestReadyPackageForApplicationReturns
	fake.recordInvocation("GetNewestReadyPackageForApplication", []interface{}{arg1})
	fake.getNewestReadyPackageForApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrgUsersByRoleTypeStub
	fakeReturns := fake.getOrgUsersByRoleTypeReturns
	fake.recordInvocation("GetOrgUsersByRoleType", []interface{}{arg1})
	fake.getOrgUsersByRoleTypeMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationByNameStub
	fakeReturns := fake.getOrganizationByNameReturns
	fake.recordInvocation("GetOrganizationByName", []interface{}{arg1})
	fake.getOrganizationByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationDomainsStub
	fakeReturns := fake.getOrganizationDomainsReturns
	fake.recordInvocation("GetOrganizationDomains", []interface{}{arg1, arg2})
	fake.getOrganizationDomainsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationLabelsStub
	fakeReturns := fake.getOrganizationLabelsReturns
	fake.recordInvocation("GetOrganizationLabels", []interface{}{arg1})
	fake.getOrganizationLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationQuotaByNameStub
	fakeReturns := fake.getOrganizationQuotaByNameReturns
	fake.recordInvocation("GetOrganizationQuotaByName", []interface{}{arg1})
	fake.getOrganizationQuotaByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetOrganizationQuotasStub
	fakeReturns := fake.getOrganizationQuotasReturns
	fake.recordInvocation("GetOrganizationQuotas", []interface{}{})
	fake.getOrganizationQuotasMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationSpacesStub
	fakeReturns := fake.getOrganizationSpacesReturns
	fake.recordInvocation("GetOrganizationSpaces", []interface{}{arg1})
	fake.getOrganizationSpacesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationSpacesWithLabelSelectorStub
	fakeReturns := fake.getOrganizationSpacesWithLabelSelectorReturns
	fake.recordInvocation("GetOrganizationSpacesWithLabelSelector", []interface{}{arg1, arg2})
	fake.getOrganizationSpacesWithLabelSelectorMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationSummaryByNameStub
	fakeReturns := fake.getOrganizationSummaryByNameReturns
	fake.recordInvocation("GetOrganizationSummaryByName", []interface{}{arg1})
	fake.getOrganizationSummaryByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetOrganizationsStub
	fakeReturns := fake.getOrganizationsReturns
	fake.recordInvocation("GetOrganizations", []interface{}{arg1})
	fake.getOrganizationsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetProcessByTypeAndApplicationStub
	fakeReturns := fake.getProcessByTypeAndApplicationReturns
	fake.recordInvocation("GetProcessByTypeAndApplication", []interface{}{arg1, arg2})
	fake.getProcessByTypeAndApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRawApplicationManifestByNameAndSpaceStub
	fakeReturns := fake.getRawApplicationManifestByNameAndSpaceReturns
	fake.recordInvocation("GetRawApplicationManifestByNameAndSpace", []interface{}{arg1, arg2})
	fake.getRawApplicationManifestByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRecentEventsByApplicationNameAndSpaceStub
	fakeReturns := fake.getRecentEventsByApplicationNameAndSpaceReturns
	fake.recordInvocation("GetRecentEventsByApplicationNameAndSpace", []interface{}{arg1, arg2})
	fake.getRecentEventsByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRecentLogsForApplicationByNameAndSpaceStub
	fakeReturns := fake.getRecentLogsForApplicationByNameAndSpaceReturns
	fake.recordInvocation("GetRecentLogsForApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.getRecentLogsForApplicationByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRevisionByApplicationAndVersionStub
	fakeReturns := fake.getRevisionByApplicationAndVersionReturns
	fake.recordInvocation("GetRevisionByApplicationAndVersion", []interface{}{arg1, arg2})
	fake.getRevisionByApplicationAndVersionMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRevisionsByApplicationNameAndSpaceStub
	fakeReturns := fake.getRevisionsByApplicationNameAndSpaceReturns
	fake.recordInvocation("GetRevisionsByApplicationNameAndSpace", []interface{}{arg1, arg2})
	fake.getRevisionsByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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.Root, v7action.Warnings, error) {
	fake.getRootResponseMutex.Lock()
	ret, specificReturn := fake.getRootResponseReturnsOnCall[len(fake.getRootResponseArgsForCall)]
	fake.getRootResponseArgsForCall = append(fake.getRootResponseArgsForCall, struct {
	}{})
	stub := fake.GetRootResponseStub
	fakeReturns := fake.getRootResponseReturns
	fake.recordInvocation("GetRootResponse", []interface{}{})
	fake.getRootResponseMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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.Root, v7action.Warnings, error)) {
	fake.getRootResponseMutex.Lock()
	defer fake.getRootResponseMutex.Unlock()
	fake.GetRootResponseStub = stub
}

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

func (fake *FakeActor) GetRootResponseReturnsOnCall(i int, result1 v7action.Root, 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.Root
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.getRootResponseReturnsOnCall[i] = struct {
		result1 v7action.Root
		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})
	stub := fake.GetRouteByAttributesStub
	fakeReturns := fake.getRouteByAttributesReturns
	fake.recordInvocation("GetRouteByAttributes", []interface{}{arg1, arg2, arg3, arg4})
	fake.getRouteByAttributesMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRouteDestinationByAppGUIDStub
	fakeReturns := fake.getRouteDestinationByAppGUIDReturns
	fake.recordInvocation("GetRouteDestinationByAppGUID", []interface{}{arg1, arg2})
	fake.getRouteDestinationByAppGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetRouteLabelsStub
	fakeReturns := fake.getRouteLabelsReturns
	fake.recordInvocation("GetRouteLabels", []interface{}{arg1, arg2})
	fake.getRouteLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRouteSummariesStub
	fakeReturns := fake.getRouteSummariesReturns
	fake.recordInvocation("GetRouteSummaries", []interface{}{arg1Copy})
	fake.getRouteSummariesMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetRouterGroupsStub
	fakeReturns := fake.getRouterGroupsReturns
	fake.recordInvocation("GetRouterGroups", []interface{}{})
	fake.getRouterGroupsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetRoutesByOrgStub
	fakeReturns := fake.getRoutesByOrgReturns
	fake.recordInvocation("GetRoutesByOrg", []interface{}{arg1, arg2})
	fake.getRoutesByOrgMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetRoutesBySpaceStub
	fakeReturns := fake.getRoutesBySpaceReturns
	fake.recordInvocation("GetRoutesBySpace", []interface{}{arg1, arg2})
	fake.getRoutesBySpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSSHEnabledStub
	fakeReturns := fake.getSSHEnabledReturns
	fake.recordInvocation("GetSSHEnabled", []interface{}{arg1})
	fake.getSSHEnabledMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSSHEnabledByAppNameStub
	fakeReturns := fake.getSSHEnabledByAppNameReturns
	fake.recordInvocation("GetSSHEnabledByAppName", []interface{}{arg1, arg2})
	fake.getSSHEnabledByAppNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetSSHPasscodeStub
	fakeReturns := fake.getSSHPasscodeReturns
	fake.recordInvocation("GetSSHPasscode", []interface{}{})
	fake.getSSHPasscodeMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexStub
	fakeReturns := fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexReturns
	fake.recordInvocation("GetSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndex", []interface{}{arg1, arg2, arg3, arg4})
	fake.getSecureShellConfigurationByApplicationNameSpaceProcessTypeAndIndexMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSecurityGroupStub
	fakeReturns := fake.getSecurityGroupReturns
	fake.recordInvocation("GetSecurityGroup", []interface{}{arg1})
	fake.getSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSecurityGroupSummaryStub
	fakeReturns := fake.getSecurityGroupSummaryReturns
	fake.recordInvocation("GetSecurityGroupSummary", []interface{}{arg1})
	fake.getSecurityGroupSummaryMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetSecurityGroupsStub
	fakeReturns := fake.getSecurityGroupsReturns
	fake.recordInvocation("GetSecurityGroups", []interface{}{})
	fake.getSecurityGroupsMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceAccessStub
	fakeReturns := fake.getServiceAccessReturns
	fake.recordInvocation("GetServiceAccess", []interface{}{arg1, arg2, arg3})
	fake.getServiceAccessMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceBrokerByNameStub
	fakeReturns := fake.getServiceBrokerByNameReturns
	fake.recordInvocation("GetServiceBrokerByName", []interface{}{arg1})
	fake.getServiceBrokerByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceBrokerLabelsStub
	fakeReturns := fake.getServiceBrokerLabelsReturns
	fake.recordInvocation("GetServiceBrokerLabels", []interface{}{arg1})
	fake.getServiceBrokerLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetServiceBrokersStub
	fakeReturns := fake.getServiceBrokersReturns
	fake.recordInvocation("GetServiceBrokers", []interface{}{})
	fake.getServiceBrokersMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceInstanceByNameAndSpaceStub
	fakeReturns := fake.getServiceInstanceByNameAndSpaceReturns
	fake.recordInvocation("GetServiceInstanceByNameAndSpace", []interface{}{arg1, arg2})
	fake.getServiceInstanceByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceInstanceDetailsStub
	fakeReturns := fake.getServiceInstanceDetailsReturns
	fake.recordInvocation("GetServiceInstanceDetails", []interface{}{arg1, arg2, arg3})
	fake.getServiceInstanceDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceInstanceLabelsStub
	fakeReturns := fake.getServiceInstanceLabelsReturns
	fake.recordInvocation("GetServiceInstanceLabels", []interface{}{arg1, arg2})
	fake.getServiceInstanceLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceInstanceParametersStub
	fakeReturns := fake.getServiceInstanceParametersReturns
	fake.recordInvocation("GetServiceInstanceParameters", []interface{}{arg1, arg2})
	fake.getServiceInstanceParametersMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceInstancesForSpaceStub
	fakeReturns := fake.getServiceInstancesForSpaceReturns
	fake.recordInvocation("GetServiceInstancesForSpace", []interface{}{arg1, arg2})
	fake.getServiceInstancesForSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceKeyByServiceInstanceAndNameStub
	fakeReturns := fake.getServiceKeyByServiceInstanceAndNameReturns
	fake.recordInvocation("GetServiceKeyByServiceInstanceAndName", []interface{}{arg1, arg2, arg3})
	fake.getServiceKeyByServiceInstanceAndNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceKeyDetailsByServiceInstanceAndNameStub
	fakeReturns := fake.getServiceKeyDetailsByServiceInstanceAndNameReturns
	fake.recordInvocation("GetServiceKeyDetailsByServiceInstanceAndName", []interface{}{arg1, arg2, arg3})
	fake.getServiceKeyDetailsByServiceInstanceAndNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceKeysByServiceInstanceStub
	fakeReturns := fake.getServiceKeysByServiceInstanceReturns
	fake.recordInvocation("GetServiceKeysByServiceInstance", []interface{}{arg1, arg2})
	fake.getServiceKeysByServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServiceOfferingLabelsStub
	fakeReturns := fake.getServiceOfferingLabelsReturns
	fake.recordInvocation("GetServiceOfferingLabels", []interface{}{arg1, arg2})
	fake.getServiceOfferingLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServicePlanByNameOfferingAndBrokerStub
	fakeReturns := fake.getServicePlanByNameOfferingAndBrokerReturns
	fake.recordInvocation("GetServicePlanByNameOfferingAndBroker", []interface{}{arg1, arg2, arg3})
	fake.getServicePlanByNameOfferingAndBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetServicePlanLabelsStub
	fakeReturns := fake.getServicePlanLabelsReturns
	fake.recordInvocation("GetServicePlanLabels", []interface{}{arg1, arg2, arg3})
	fake.getServicePlanLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceByNameAndOrganizationStub
	fakeReturns := fake.getSpaceByNameAndOrganizationReturns
	fake.recordInvocation("GetSpaceByNameAndOrganization", []interface{}{arg1, arg2})
	fake.getSpaceByNameAndOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceFeatureStub
	fakeReturns := fake.getSpaceFeatureReturns
	fake.recordInvocation("GetSpaceFeature", []interface{}{arg1, arg2, arg3})
	fake.getSpaceFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceLabelsStub
	fakeReturns := fake.getSpaceLabelsReturns
	fake.recordInvocation("GetSpaceLabels", []interface{}{arg1, arg2})
	fake.getSpaceLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceQuotaByNameStub
	fakeReturns := fake.getSpaceQuotaByNameReturns
	fake.recordInvocation("GetSpaceQuotaByName", []interface{}{arg1, arg2})
	fake.getSpaceQuotaByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceQuotasByOrgGUIDStub
	fakeReturns := fake.getSpaceQuotasByOrgGUIDReturns
	fake.recordInvocation("GetSpaceQuotasByOrgGUID", []interface{}{arg1})
	fake.getSpaceQuotasByOrgGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceSummaryByNameAndOrganizationStub
	fakeReturns := fake.getSpaceSummaryByNameAndOrganizationReturns
	fake.recordInvocation("GetSpaceSummaryByNameAndOrganization", []interface{}{arg1, arg2})
	fake.getSpaceSummaryByNameAndOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetSpaceUsersByRoleTypeStub
	fakeReturns := fake.getSpaceUsersByRoleTypeReturns
	fake.recordInvocation("GetSpaceUsersByRoleType", []interface{}{arg1})
	fake.getSpaceUsersByRoleTypeMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetStackByNameStub
	fakeReturns := fake.getStackByNameReturns
	fake.recordInvocation("GetStackByName", []interface{}{arg1})
	fake.getStackByNameMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetStackLabelsStub
	fakeReturns := fake.getStackLabelsReturns
	fake.recordInvocation("GetStackLabels", []interface{}{arg1})
	fake.getStackLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetStacksStub
	fakeReturns := fake.getStacksReturns
	fake.recordInvocation("GetStacks", []interface{}{arg1})
	fake.getStacksMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetStreamingLogsForApplicationByNameAndSpaceStub
	fakeReturns := fake.getStreamingLogsForApplicationByNameAndSpaceReturns
	fake.recordInvocation("GetStreamingLogsForApplicationByNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.getStreamingLogsForApplicationByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3, ret.result4, ret.result5
	}
	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})
	stub := fake.GetTaskBySequenceIDAndApplicationStub
	fakeReturns := fake.getTaskBySequenceIDAndApplicationReturns
	fake.recordInvocation("GetTaskBySequenceIDAndApplication", []interface{}{arg1, arg2})
	fake.getTaskBySequenceIDAndApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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 {
	}{})
	stub := fake.GetUAAAPIVersionStub
	fakeReturns := fake.getUAAAPIVersionReturns
	fake.recordInvocation("GetUAAAPIVersion", []interface{}{})
	fake.getUAAAPIVersionMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.GetUnstagedNewestPackageGUIDStub
	fakeReturns := fake.getUnstagedNewestPackageGUIDReturns
	fake.recordInvocation("GetUnstagedNewestPackageGUID", []interface{}{arg1})
	fake.getUnstagedNewestPackageGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.GetUserStub
	fakeReturns := fake.getUserReturns
	fake.recordInvocation("GetUser", []interface{}{arg1, arg2})
	fake.getUserMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.MakeCurlRequestStub
	fakeReturns := fake.makeCurlRequestReturns
	fake.recordInvocation("MakeCurlRequest", []interface{}{arg1, arg2, arg3Copy, arg4, arg5})
	fake.makeCurlRequestMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.MapRouteStub
	fakeReturns := fake.mapRouteReturns
	fake.recordInvocation("MapRoute", []interface{}{arg1, arg2, arg3})
	fake.mapRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.MarketplaceStub
	fakeReturns := fake.marketplaceReturns
	fake.recordInvocation("Marketplace", []interface{}{arg1})
	fake.marketplaceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.MoveRouteStub
	fakeReturns := fake.moveRouteReturns
	fake.recordInvocation("MoveRoute", []interface{}{arg1, arg2})
	fake.moveRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.ParseAccessTokenStub
	fakeReturns := fake.parseAccessTokenReturns
	fake.recordInvocation("ParseAccessToken", []interface{}{arg1})
	fake.parseAccessTokenMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.PollBuildStub
	fakeReturns := fake.pollBuildReturns
	fake.recordInvocation("PollBuild", []interface{}{arg1, arg2})
	fake.pollBuildMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.PollPackageStub
	fakeReturns := fake.pollPackageReturns
	fake.recordInvocation("PollPackage", []interface{}{arg1})
	fake.pollPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.PollStartStub
	fakeReturns := fake.pollStartReturns
	fake.recordInvocation("PollStart", []interface{}{arg1, arg2, arg3})
	fake.pollStartMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) PollStartForDeployment(arg1 resources.Application, arg2 string, arg3 bool, arg4 func(string)) (v7action.Warnings, error) {
	fake.pollStartForDeploymentMutex.Lock()
	ret, specificReturn := fake.pollStartForDeploymentReturnsOnCall[len(fake.pollStartForDeploymentArgsForCall)]
	fake.pollStartForDeploymentArgsForCall = append(fake.pollStartForDeploymentArgsForCall, struct {
		arg1 resources.Application
		arg2 string
		arg3 bool
		arg4 func(string)
	}{arg1, arg2, arg3, arg4})
	stub := fake.PollStartForDeploymentStub
	fakeReturns := fake.pollStartForDeploymentReturns
	fake.recordInvocation("PollStartForDeployment", []interface{}{arg1, arg2, arg3, arg4})
	fake.pollStartForDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) PollStartForDeploymentCallCount() int {
	fake.pollStartForDeploymentMutex.RLock()
	defer fake.pollStartForDeploymentMutex.RUnlock()
	return len(fake.pollStartForDeploymentArgsForCall)
}

func (fake *FakeActor) PollStartForDeploymentCalls(stub func(resources.Application, string, bool, func(string)) (v7action.Warnings, error)) {
	fake.pollStartForDeploymentMutex.Lock()
	defer fake.pollStartForDeploymentMutex.Unlock()
	fake.PollStartForDeploymentStub = stub
}

func (fake *FakeActor) PollStartForDeploymentArgsForCall(i int) (resources.Application, string, bool, func(string)) {
	fake.pollStartForDeploymentMutex.RLock()
	defer fake.pollStartForDeploymentMutex.RUnlock()
	argsForCall := fake.pollStartForDeploymentArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) PollStartForDeploymentReturns(result1 v7action.Warnings, result2 error) {
	fake.pollStartForDeploymentMutex.Lock()
	defer fake.pollStartForDeploymentMutex.Unlock()
	fake.PollStartForDeploymentStub = nil
	fake.pollStartForDeploymentReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) PollStartForDeploymentReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.pollStartForDeploymentMutex.Lock()
	defer fake.pollStartForDeploymentMutex.Unlock()
	fake.PollStartForDeploymentStub = nil
	if fake.pollStartForDeploymentReturnsOnCall == nil {
		fake.pollStartForDeploymentReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.pollStartForDeploymentReturnsOnCall[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})
	stub := fake.PollTaskStub
	fakeReturns := fake.pollTaskReturns
	fake.recordInvocation("PollTask", []interface{}{arg1})
	fake.pollTaskMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.PollUploadBuildpackJobStub
	fakeReturns := fake.pollUploadBuildpackJobReturns
	fake.recordInvocation("PollUploadBuildpackJob", []interface{}{arg1})
	fake.pollUploadBuildpackJobMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.PrepareBuildpackBitsStub
	fakeReturns := fake.prepareBuildpackBitsReturns
	fake.recordInvocation("PrepareBuildpackBits", []interface{}{arg1, arg2, arg3})
	fake.prepareBuildpackBitsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.PurgeServiceInstanceStub
	fakeReturns := fake.purgeServiceInstanceReturns
	fake.recordInvocation("PurgeServiceInstance", []interface{}{arg1, arg2})
	fake.purgeServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.PurgeServiceOfferingByNameAndBrokerStub
	fakeReturns := fake.purgeServiceOfferingByNameAndBrokerReturns
	fake.recordInvocation("PurgeServiceOfferingByNameAndBroker", []interface{}{arg1, arg2})
	fake.purgeServiceOfferingByNameAndBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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 {
	}{})
	stub := fake.RefreshAccessTokenStub
	fakeReturns := fake.refreshAccessTokenReturns
	fake.recordInvocation("RefreshAccessToken", []interface{}{})
	fake.refreshAccessTokenMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.RenameApplicationByNameAndSpaceGUIDStub
	fakeReturns := fake.renameApplicationByNameAndSpaceGUIDReturns
	fake.recordInvocation("RenameApplicationByNameAndSpaceGUID", []interface{}{arg1, arg2, arg3})
	fake.renameApplicationByNameAndSpaceGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.RenameOrganizationStub
	fakeReturns := fake.renameOrganizationReturns
	fake.recordInvocation("RenameOrganization", []interface{}{arg1, arg2})
	fake.renameOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.RenameServiceInstanceStub
	fakeReturns := fake.renameServiceInstanceReturns
	fake.recordInvocation("RenameServiceInstance", []interface{}{arg1, arg2, arg3})
	fake.renameServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.RenameSpaceByNameAndOrganizationGUIDStub
	fakeReturns := fake.renameSpaceByNameAndOrganizationGUIDReturns
	fake.recordInvocation("RenameSpaceByNameAndOrganizationGUID", []interface{}{arg1, arg2, arg3})
	fake.renameSpaceByNameAndOrganizationGUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.ResetOrganizationDefaultIsolationSegmentStub
	fakeReturns := fake.resetOrganizationDefaultIsolationSegmentReturns
	fake.recordInvocation("ResetOrganizationDefaultIsolationSegment", []interface{}{arg1})
	fake.resetOrganizationDefaultIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.ResetSpaceIsolationSegmentStub
	fakeReturns := fake.resetSpaceIsolationSegmentReturns
	fake.recordInvocation("ResetSpaceIsolationSegment", []interface{}{arg1, arg2})
	fake.resetSpaceIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.ResourceMatchStub
	fakeReturns := fake.resourceMatchReturns
	fake.recordInvocation("ResourceMatch", []interface{}{arg1Copy})
	fake.resourceMatchMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.RestartApplicationStub
	fakeReturns := fake.restartApplicationReturns
	fake.recordInvocation("RestartApplication", []interface{}{arg1, arg2})
	fake.restartApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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 {
	}{})
	stub := fake.RevokeAccessAndRefreshTokensStub
	fakeReturns := fake.revokeAccessAndRefreshTokensReturns
	fake.recordInvocation("RevokeAccessAndRefreshTokens", []interface{}{})
	fake.revokeAccessAndRefreshTokensMutex.Unlock()
	if stub != nil {
		return stub()
	}
	if specificReturn {
		return ret.result1
	}
	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})
	stub := fake.RunTaskStub
	fakeReturns := fake.runTaskReturns
	fake.recordInvocation("RunTask", []interface{}{arg1, arg2})
	fake.runTaskMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.ScaleProcessByApplicationStub
	fakeReturns := fake.scaleProcessByApplicationReturns
	fake.recordInvocation("ScaleProcessByApplication", []interface{}{arg1, arg2})
	fake.scaleProcessByApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.ScheduleTokenRefreshStub
	fakeReturns := fake.scheduleTokenRefreshReturns
	fake.recordInvocation("ScheduleTokenRefresh", []interface{}{arg1, arg2, arg3})
	fake.scheduleTokenRefreshMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetApplicationDropletStub
	fakeReturns := fake.setApplicationDropletReturns
	fake.recordInvocation("SetApplicationDroplet", []interface{}{arg1, arg2})
	fake.setApplicationDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetApplicationDropletByApplicationNameAndSpaceStub
	fakeReturns := fake.setApplicationDropletByApplicationNameAndSpaceReturns
	fake.recordInvocation("SetApplicationDropletByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.setApplicationDropletByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetApplicationManifestStub
	fakeReturns := fake.setApplicationManifestReturns
	fake.recordInvocation("SetApplicationManifest", []interface{}{arg1, arg2Copy})
	fake.setApplicationManifestMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetApplicationProcessHealthCheckTypeByNameAndSpaceStub
	fakeReturns := fake.setApplicationProcessHealthCheckTypeByNameAndSpaceReturns
	fake.recordInvocation("SetApplicationProcessHealthCheckTypeByNameAndSpace", []interface{}{arg1, arg2, arg3, arg4, arg5, arg6})
	fake.setApplicationProcessHealthCheckTypeByNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4, arg5, arg6)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.SetEnvironmentVariableByApplicationNameAndSpaceStub
	fakeReturns := fake.setEnvironmentVariableByApplicationNameAndSpaceReturns
	fake.recordInvocation("SetEnvironmentVariableByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.setEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetEnvironmentVariableGroupStub
	fakeReturns := fake.setEnvironmentVariableGroupReturns
	fake.recordInvocation("SetEnvironmentVariableGroup", []interface{}{arg1, arg2})
	fake.setEnvironmentVariableGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetOrganizationDefaultIsolationSegmentStub
	fakeReturns := fake.setOrganizationDefaultIsolationSegmentReturns
	fake.recordInvocation("SetOrganizationDefaultIsolationSegment", []interface{}{arg1, arg2})
	fake.setOrganizationDefaultIsolationSegmentMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetSpaceManifestStub
	fakeReturns := fake.setSpaceManifestReturns
	fake.recordInvocation("SetSpaceManifest", []interface{}{arg1, arg2Copy})
	fake.setSpaceManifestMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SetTargetStub
	fakeReturns := fake.setTargetReturns
	fake.recordInvocation("SetTarget", []interface{}{arg1})
	fake.setTargetMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.SharePrivateDomainStub
	fakeReturns := fake.sharePrivateDomainReturns
	fake.recordInvocation("SharePrivateDomain", []interface{}{arg1, arg2})
	fake.sharePrivateDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.ShareRouteStub
	fakeReturns := fake.shareRouteReturns
	fake.recordInvocation("ShareRoute", []interface{}{arg1, arg2})
	fake.shareRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.ShareServiceInstanceToSpaceAndOrgStub
	fakeReturns := fake.shareServiceInstanceToSpaceAndOrgReturns
	fake.recordInvocation("ShareServiceInstanceToSpaceAndOrg", []interface{}{arg1, arg2, arg3, arg4})
	fake.shareServiceInstanceToSpaceAndOrgMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.StageApplicationPackageStub
	fakeReturns := fake.stageApplicationPackageReturns
	fake.recordInvocation("StageApplicationPackage", []interface{}{arg1})
	fake.stageApplicationPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.StagePackageStub
	fakeReturns := fake.stagePackageReturns
	fake.recordInvocation("StagePackage", []interface{}{arg1, arg2, arg3})
	fake.stagePackageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.StartApplicationStub
	fakeReturns := fake.startApplicationReturns
	fake.recordInvocation("StartApplication", []interface{}{arg1})
	fake.startApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.StopApplicationStub
	fakeReturns := fake.stopApplicationReturns
	fake.recordInvocation("StopApplication", []interface{}{arg1})
	fake.stopApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.TerminateTaskStub
	fakeReturns := fake.terminateTaskReturns
	fake.recordInvocation("TerminateTask", []interface{}{arg1})
	fake.terminateTaskMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.UnbindSecurityGroupStub
	fakeReturns := fake.unbindSecurityGroupReturns
	fake.recordInvocation("UnbindSecurityGroup", []interface{}{arg1, arg2, arg3, arg4})
	fake.unbindSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UnmapRouteStub
	fakeReturns := fake.unmapRouteReturns
	fake.recordInvocation("UnmapRoute", []interface{}{arg1, arg2})
	fake.unmapRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UnsetEnvironmentVariableByApplicationNameAndSpaceStub
	fakeReturns := fake.unsetEnvironmentVariableByApplicationNameAndSpaceReturns
	fake.recordInvocation("UnsetEnvironmentVariableByApplicationNameAndSpace", []interface{}{arg1, arg2, arg3})
	fake.unsetEnvironmentVariableByApplicationNameAndSpaceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UnsetSpaceQuotaStub
	fakeReturns := fake.unsetSpaceQuotaReturns
	fake.recordInvocation("UnsetSpaceQuota", []interface{}{arg1, arg2, arg3})
	fake.unsetSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UnsharePrivateDomainStub
	fakeReturns := fake.unsharePrivateDomainReturns
	fake.recordInvocation("UnsharePrivateDomain", []interface{}{arg1, arg2})
	fake.unsharePrivateDomainMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UnshareRouteStub
	fakeReturns := fake.unshareRouteReturns
	fake.recordInvocation("UnshareRoute", []interface{}{arg1, arg2})
	fake.unshareRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UnshareServiceInstanceFromSpaceAndOrgStub
	fakeReturns := fake.unshareServiceInstanceFromSpaceAndOrgReturns
	fake.recordInvocation("UnshareServiceInstanceFromSpaceAndOrg", []interface{}{arg1, arg2, arg3, arg4})
	fake.unshareServiceInstanceFromSpaceAndOrgMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateAppFeatureStub
	fakeReturns := fake.updateAppFeatureReturns
	fake.recordInvocation("UpdateAppFeature", []interface{}{arg1, arg2, arg3})
	fake.updateAppFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateApplicationStub
	fakeReturns := fake.updateApplicationReturns
	fake.recordInvocation("UpdateApplication", []interface{}{arg1})
	fake.updateApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.UpdateApplicationLabelsByApplicationNameStub
	fakeReturns := fake.updateApplicationLabelsByApplicationNameReturns
	fake.recordInvocation("UpdateApplicationLabelsByApplicationName", []interface{}{arg1, arg2, arg3})
	fake.updateApplicationLabelsByApplicationNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) UpdateBuildpackByNameAndStackAndLifecycle(arg1 string, arg2 string, arg3 string, arg4 resources.Buildpack) (resources.Buildpack, v7action.Warnings, error) {
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.Lock()
	ret, specificReturn := fake.updateBuildpackByNameAndStackAndLifecycleReturnsOnCall[len(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall)]
	fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall = append(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 resources.Buildpack
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateBuildpackByNameAndStackAndLifecycleStub
	fakeReturns := fake.updateBuildpackByNameAndStackAndLifecycleReturns
	fake.recordInvocation("UpdateBuildpackByNameAndStackAndLifecycle", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleCallCount() int {
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.RLock()
	defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.RUnlock()
	return len(fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall)
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleCalls(stub func(string, string, string, resources.Buildpack) (resources.Buildpack, v7action.Warnings, error)) {
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.Lock()
	defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	fake.UpdateBuildpackByNameAndStackAndLifecycleStub = stub
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleArgsForCall(i int) (string, string, string, resources.Buildpack) {
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.RLock()
	defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.RUnlock()
	argsForCall := fake.updateBuildpackByNameAndStackAndLifecycleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleReturns(result1 resources.Buildpack, result2 v7action.Warnings, result3 error) {
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.Lock()
	defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	fake.UpdateBuildpackByNameAndStackAndLifecycleStub = nil
	fake.updateBuildpackByNameAndStackAndLifecycleReturns = struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateBuildpackByNameAndStackAndLifecycleReturnsOnCall(i int, result1 resources.Buildpack, result2 v7action.Warnings, result3 error) {
	fake.updateBuildpackByNameAndStackAndLifecycleMutex.Lock()
	defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.Unlock()
	fake.UpdateBuildpackByNameAndStackAndLifecycleStub = nil
	if fake.updateBuildpackByNameAndStackAndLifecycleReturnsOnCall == nil {
		fake.updateBuildpackByNameAndStackAndLifecycleReturnsOnCall = make(map[int]struct {
			result1 resources.Buildpack
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.updateBuildpackByNameAndStackAndLifecycleReturnsOnCall[i] = struct {
		result1 resources.Buildpack
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycle(arg1 string, arg2 string, arg3 string, arg4 map[string]types.NullString) (v7action.Warnings, error) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Lock()
	ret, specificReturn := fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall[len(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall)]
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall = append(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall, struct {
		arg1 string
		arg2 string
		arg3 string
		arg4 map[string]types.NullString
	}{arg1, arg2, arg3, arg4})
	stub := fake.UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleStub
	fakeReturns := fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns
	fake.recordInvocation("UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycle", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleCallCount() int {
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RLock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RUnlock()
	return len(fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall)
}

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

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall(i int) (string, string, string, map[string]types.NullString) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RLock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RUnlock()
	argsForCall := fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns(result1 v7action.Warnings, result2 error) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Lock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Unlock()
	fake.UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleStub = nil
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturns = struct {
		result1 v7action.Warnings
		result2 error
	}{result1, result2}
}

func (fake *FakeActor) UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall(i int, result1 v7action.Warnings, result2 error) {
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Lock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.Unlock()
	fake.UpdateBuildpackLabelsByBuildpackNameAndStackAndLifecycleStub = nil
	if fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall == nil {
		fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall = make(map[int]struct {
			result1 v7action.Warnings
			result2 error
		})
	}
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleReturnsOnCall[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})
	stub := fake.UpdateDestinationStub
	fakeReturns := fake.updateDestinationReturns
	fake.recordInvocation("UpdateDestination", []interface{}{arg1, arg2, arg3})
	fake.updateDestinationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateDomainLabelsByDomainNameStub
	fakeReturns := fake.updateDomainLabelsByDomainNameReturns
	fake.recordInvocation("UpdateDomainLabelsByDomainName", []interface{}{arg1, arg2})
	fake.updateDomainLabelsByDomainNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateManagedServiceInstanceStub
	fakeReturns := fake.updateManagedServiceInstanceReturns
	fake.recordInvocation("UpdateManagedServiceInstance", []interface{}{arg1})
	fake.updateManagedServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.UpdateOrganizationLabelsByOrganizationNameStub
	fakeReturns := fake.updateOrganizationLabelsByOrganizationNameReturns
	fake.recordInvocation("UpdateOrganizationLabelsByOrganizationName", []interface{}{arg1, arg2})
	fake.updateOrganizationLabelsByOrganizationNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateOrganizationQuotaStub
	fakeReturns := fake.updateOrganizationQuotaReturns
	fake.recordInvocation("UpdateOrganizationQuota", []interface{}{arg1, arg2, arg3})
	fake.updateOrganizationQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateProcessByTypeAndApplicationStub
	fakeReturns := fake.updateProcessByTypeAndApplicationReturns
	fake.recordInvocation("UpdateProcessByTypeAndApplication", []interface{}{arg1, arg2, arg3})
	fake.updateProcessByTypeAndApplicationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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) UpdateRoute(arg1 string, arg2 map[string]*string) (resources.Route, v7action.Warnings, error) {
	fake.updateRouteMutex.Lock()
	ret, specificReturn := fake.updateRouteReturnsOnCall[len(fake.updateRouteArgsForCall)]
	fake.updateRouteArgsForCall = append(fake.updateRouteArgsForCall, struct {
		arg1 string
		arg2 map[string]*string
	}{arg1, arg2})
	stub := fake.UpdateRouteStub
	fakeReturns := fake.updateRouteReturns
	fake.recordInvocation("UpdateRoute", []interface{}{arg1, arg2})
	fake.updateRouteMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
}

func (fake *FakeActor) UpdateRouteCallCount() int {
	fake.updateRouteMutex.RLock()
	defer fake.updateRouteMutex.RUnlock()
	return len(fake.updateRouteArgsForCall)
}

func (fake *FakeActor) UpdateRouteCalls(stub func(string, map[string]*string) (resources.Route, v7action.Warnings, error)) {
	fake.updateRouteMutex.Lock()
	defer fake.updateRouteMutex.Unlock()
	fake.UpdateRouteStub = stub
}

func (fake *FakeActor) UpdateRouteArgsForCall(i int) (string, map[string]*string) {
	fake.updateRouteMutex.RLock()
	defer fake.updateRouteMutex.RUnlock()
	argsForCall := fake.updateRouteArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeActor) UpdateRouteReturns(result1 resources.Route, result2 v7action.Warnings, result3 error) {
	fake.updateRouteMutex.Lock()
	defer fake.updateRouteMutex.Unlock()
	fake.UpdateRouteStub = nil
	fake.updateRouteReturns = struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

func (fake *FakeActor) UpdateRouteReturnsOnCall(i int, result1 resources.Route, result2 v7action.Warnings, result3 error) {
	fake.updateRouteMutex.Lock()
	defer fake.updateRouteMutex.Unlock()
	fake.UpdateRouteStub = nil
	if fake.updateRouteReturnsOnCall == nil {
		fake.updateRouteReturnsOnCall = make(map[int]struct {
			result1 resources.Route
			result2 v7action.Warnings
			result3 error
		})
	}
	fake.updateRouteReturnsOnCall[i] = struct {
		result1 resources.Route
		result2 v7action.Warnings
		result3 error
	}{result1, result2, result3}
}

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})
	stub := fake.UpdateRouteLabelsStub
	fakeReturns := fake.updateRouteLabelsReturns
	fake.recordInvocation("UpdateRouteLabels", []interface{}{arg1, arg2, arg3})
	fake.updateRouteLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateSecurityGroupStub
	fakeReturns := fake.updateSecurityGroupReturns
	fake.recordInvocation("UpdateSecurityGroup", []interface{}{arg1, arg2})
	fake.updateSecurityGroupMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateSecurityGroupGloballyEnabledStub
	fakeReturns := fake.updateSecurityGroupGloballyEnabledReturns
	fake.recordInvocation("UpdateSecurityGroupGloballyEnabled", []interface{}{arg1, arg2, arg3})
	fake.updateSecurityGroupGloballyEnabledMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateServiceBrokerStub
	fakeReturns := fake.updateServiceBrokerReturns
	fake.recordInvocation("UpdateServiceBroker", []interface{}{arg1, arg2})
	fake.updateServiceBrokerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateServiceBrokerLabelsByServiceBrokerNameStub
	fakeReturns := fake.updateServiceBrokerLabelsByServiceBrokerNameReturns
	fake.recordInvocation("UpdateServiceBrokerLabelsByServiceBrokerName", []interface{}{arg1, arg2})
	fake.updateServiceBrokerLabelsByServiceBrokerNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateServiceInstanceLabelsStub
	fakeReturns := fake.updateServiceInstanceLabelsReturns
	fake.recordInvocation("UpdateServiceInstanceLabels", []interface{}{arg1, arg2, arg3})
	fake.updateServiceInstanceLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateServiceOfferingLabelsStub
	fakeReturns := fake.updateServiceOfferingLabelsReturns
	fake.recordInvocation("UpdateServiceOfferingLabels", []interface{}{arg1, arg2, arg3})
	fake.updateServiceOfferingLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateServicePlanLabelsStub
	fakeReturns := fake.updateServicePlanLabelsReturns
	fake.recordInvocation("UpdateServicePlanLabels", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateServicePlanLabelsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateSpaceFeatureStub
	fakeReturns := fake.updateSpaceFeatureReturns
	fake.recordInvocation("UpdateSpaceFeature", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateSpaceFeatureMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateSpaceLabelsBySpaceNameStub
	fakeReturns := fake.updateSpaceLabelsBySpaceNameReturns
	fake.recordInvocation("UpdateSpaceLabelsBySpaceName", []interface{}{arg1, arg2, arg3})
	fake.updateSpaceLabelsBySpaceNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateSpaceQuotaStub
	fakeReturns := fake.updateSpaceQuotaReturns
	fake.recordInvocation("UpdateSpaceQuota", []interface{}{arg1, arg2, arg3, arg4})
	fake.updateSpaceQuotaMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateStackLabelsByStackNameStub
	fakeReturns := fake.updateStackLabelsByStackNameReturns
	fake.recordInvocation("UpdateStackLabelsByStackName", []interface{}{arg1, arg2})
	fake.updateStackLabelsByStackNameMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpdateUserPasswordStub
	fakeReturns := fake.updateUserPasswordReturns
	fake.recordInvocation("UpdateUserPassword", []interface{}{arg1, arg2, arg3})
	fake.updateUserPasswordMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	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})
	stub := fake.UpdateUserProvidedServiceInstanceStub
	fakeReturns := fake.updateUserProvidedServiceInstanceReturns
	fake.recordInvocation("UpdateUserProvidedServiceInstance", []interface{}{arg1, arg2, arg3})
	fake.updateUserProvidedServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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})
	stub := fake.UpgradeManagedServiceInstanceStub
	fakeReturns := fake.upgradeManagedServiceInstanceReturns
	fake.recordInvocation("UpgradeManagedServiceInstance", []interface{}{arg1, arg2})
	fake.upgradeManagedServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.UploadBitsPackageStub
	fakeReturns := fake.uploadBitsPackageReturns
	fake.recordInvocation("UploadBitsPackage", []interface{}{arg1, arg2Copy, arg3, arg4})
	fake.uploadBitsPackageMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.UploadBuildpackStub
	fakeReturns := fake.uploadBuildpackReturns
	fake.recordInvocation("UploadBuildpack", []interface{}{arg1, arg2, arg3})
	fake.uploadBuildpackMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2, ret.result3
	}
	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})
	stub := fake.UploadDropletStub
	fakeReturns := fake.uploadDropletReturns
	fake.recordInvocation("UploadDroplet", []interface{}{arg1, arg2, arg3, arg4})
	fake.uploadDropletMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	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.continueDeploymentMutex.RLock()
	defer fake.continueDeploymentMutex.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.createDeploymentMutex.RLock()
	defer fake.createDeploymentMutex.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.deleteBuildpackByNameAndStackAndLifecycleMutex.RLock()
	defer fake.deleteBuildpackByNameAndStackAndLifecycleMutex.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.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RLock()
	defer fake.getApplicationProcessReadinessHealthChecksByNameAndSpaceMutex.RUnlock()
	fake.getApplicationRevisionsDeployedMutex.RLock()
	defer fake.getApplicationRevisionsDeployedMutex.RUnlock()
	fake.getApplicationRoutesMutex.RLock()
	defer fake.getApplicationRoutesMutex.RUnlock()
	fake.getApplicationTasksMutex.RLock()
	defer fake.getApplicationTasksMutex.RUnlock()
	fake.getApplicationsByGUIDsMutex.RLock()
	defer fake.getApplicationsByGUIDsMutex.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.getEnvironmentVariableGroupByRevisionMutex.RLock()
	defer fake.getEnvironmentVariableGroupByRevisionMutex.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.getInfoResponseMutex.RLock()
	defer fake.getInfoResponseMutex.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.pollStartForDeploymentMutex.RLock()
	defer fake.pollStartForDeploymentMutex.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.updateBuildpackByNameAndStackAndLifecycleMutex.RLock()
	defer fake.updateBuildpackByNameAndStackAndLifecycleMutex.RUnlock()
	fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.RLock()
	defer fake.updateBuildpackLabelsByBuildpackNameAndStackAndLifecycleMutex.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.updateRouteMutex.RLock()
	defer fake.updateRouteMutex.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)
