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

import (
	"sync"

	"github.com/cloudfoundry/cloud-service-broker/v2/brokerapi/broker"
	"github.com/cloudfoundry/cloud-service-broker/v2/internal/storage"
)

type FakeStorage struct {
	CreateServiceBindingCredentialsStub        func(storage.ServiceBindingCredentials) error
	createServiceBindingCredentialsMutex       sync.RWMutex
	createServiceBindingCredentialsArgsForCall []struct {
		arg1 storage.ServiceBindingCredentials
	}
	createServiceBindingCredentialsReturns struct {
		result1 error
	}
	createServiceBindingCredentialsReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteBindRequestDetailsStub        func(string, string) error
	deleteBindRequestDetailsMutex       sync.RWMutex
	deleteBindRequestDetailsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteBindRequestDetailsReturns struct {
		result1 error
	}
	deleteBindRequestDetailsReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteProvisionRequestDetailsStub        func(string) error
	deleteProvisionRequestDetailsMutex       sync.RWMutex
	deleteProvisionRequestDetailsArgsForCall []struct {
		arg1 string
	}
	deleteProvisionRequestDetailsReturns struct {
		result1 error
	}
	deleteProvisionRequestDetailsReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteServiceBindingCredentialsStub        func(string, string) error
	deleteServiceBindingCredentialsMutex       sync.RWMutex
	deleteServiceBindingCredentialsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	deleteServiceBindingCredentialsReturns struct {
		result1 error
	}
	deleteServiceBindingCredentialsReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteServiceInstanceDetailsStub        func(string) error
	deleteServiceInstanceDetailsMutex       sync.RWMutex
	deleteServiceInstanceDetailsArgsForCall []struct {
		arg1 string
	}
	deleteServiceInstanceDetailsReturns struct {
		result1 error
	}
	deleteServiceInstanceDetailsReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteTerraformDeploymentStub        func(string) error
	deleteTerraformDeploymentMutex       sync.RWMutex
	deleteTerraformDeploymentArgsForCall []struct {
		arg1 string
	}
	deleteTerraformDeploymentReturns struct {
		result1 error
	}
	deleteTerraformDeploymentReturnsOnCall map[int]struct {
		result1 error
	}
	ExistsServiceBindingCredentialsStub        func(string, string) (bool, error)
	existsServiceBindingCredentialsMutex       sync.RWMutex
	existsServiceBindingCredentialsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	existsServiceBindingCredentialsReturns struct {
		result1 bool
		result2 error
	}
	existsServiceBindingCredentialsReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	ExistsServiceInstanceDetailsStub        func(string) (bool, error)
	existsServiceInstanceDetailsMutex       sync.RWMutex
	existsServiceInstanceDetailsArgsForCall []struct {
		arg1 string
	}
	existsServiceInstanceDetailsReturns struct {
		result1 bool
		result2 error
	}
	existsServiceInstanceDetailsReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	ExistsTerraformDeploymentStub        func(string) (bool, error)
	existsTerraformDeploymentMutex       sync.RWMutex
	existsTerraformDeploymentArgsForCall []struct {
		arg1 string
	}
	existsTerraformDeploymentReturns struct {
		result1 bool
		result2 error
	}
	existsTerraformDeploymentReturnsOnCall map[int]struct {
		result1 bool
		result2 error
	}
	GetBindRequestDetailsStub        func(string, string) (storage.JSONObject, error)
	getBindRequestDetailsMutex       sync.RWMutex
	getBindRequestDetailsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getBindRequestDetailsReturns struct {
		result1 storage.JSONObject
		result2 error
	}
	getBindRequestDetailsReturnsOnCall map[int]struct {
		result1 storage.JSONObject
		result2 error
	}
	GetProvisionRequestDetailsStub        func(string) (storage.JSONObject, error)
	getProvisionRequestDetailsMutex       sync.RWMutex
	getProvisionRequestDetailsArgsForCall []struct {
		arg1 string
	}
	getProvisionRequestDetailsReturns struct {
		result1 storage.JSONObject
		result2 error
	}
	getProvisionRequestDetailsReturnsOnCall map[int]struct {
		result1 storage.JSONObject
		result2 error
	}
	GetServiceBindingCredentialsStub        func(string, string) (storage.ServiceBindingCredentials, error)
	getServiceBindingCredentialsMutex       sync.RWMutex
	getServiceBindingCredentialsArgsForCall []struct {
		arg1 string
		arg2 string
	}
	getServiceBindingCredentialsReturns struct {
		result1 storage.ServiceBindingCredentials
		result2 error
	}
	getServiceBindingCredentialsReturnsOnCall map[int]struct {
		result1 storage.ServiceBindingCredentials
		result2 error
	}
	GetServiceBindingIDsForServiceInstanceStub        func(string) ([]string, error)
	getServiceBindingIDsForServiceInstanceMutex       sync.RWMutex
	getServiceBindingIDsForServiceInstanceArgsForCall []struct {
		arg1 string
	}
	getServiceBindingIDsForServiceInstanceReturns struct {
		result1 []string
		result2 error
	}
	getServiceBindingIDsForServiceInstanceReturnsOnCall map[int]struct {
		result1 []string
		result2 error
	}
	GetServiceInstanceDetailsStub        func(string) (storage.ServiceInstanceDetails, error)
	getServiceInstanceDetailsMutex       sync.RWMutex
	getServiceInstanceDetailsArgsForCall []struct {
		arg1 string
	}
	getServiceInstanceDetailsReturns struct {
		result1 storage.ServiceInstanceDetails
		result2 error
	}
	getServiceInstanceDetailsReturnsOnCall map[int]struct {
		result1 storage.ServiceInstanceDetails
		result2 error
	}
	GetTerraformDeploymentStub        func(string) (storage.TerraformDeployment, error)
	getTerraformDeploymentMutex       sync.RWMutex
	getTerraformDeploymentArgsForCall []struct {
		arg1 string
	}
	getTerraformDeploymentReturns struct {
		result1 storage.TerraformDeployment
		result2 error
	}
	getTerraformDeploymentReturnsOnCall map[int]struct {
		result1 storage.TerraformDeployment
		result2 error
	}
	RemoveLockFileStub        func(string) error
	removeLockFileMutex       sync.RWMutex
	removeLockFileArgsForCall []struct {
		arg1 string
	}
	removeLockFileReturns struct {
		result1 error
	}
	removeLockFileReturnsOnCall map[int]struct {
		result1 error
	}
	StoreBindRequestDetailsStub        func(storage.BindRequestDetails) error
	storeBindRequestDetailsMutex       sync.RWMutex
	storeBindRequestDetailsArgsForCall []struct {
		arg1 storage.BindRequestDetails
	}
	storeBindRequestDetailsReturns struct {
		result1 error
	}
	storeBindRequestDetailsReturnsOnCall map[int]struct {
		result1 error
	}
	StoreProvisionRequestDetailsStub        func(string, storage.JSONObject) error
	storeProvisionRequestDetailsMutex       sync.RWMutex
	storeProvisionRequestDetailsArgsForCall []struct {
		arg1 string
		arg2 storage.JSONObject
	}
	storeProvisionRequestDetailsReturns struct {
		result1 error
	}
	storeProvisionRequestDetailsReturnsOnCall map[int]struct {
		result1 error
	}
	StoreServiceInstanceDetailsStub        func(storage.ServiceInstanceDetails) error
	storeServiceInstanceDetailsMutex       sync.RWMutex
	storeServiceInstanceDetailsArgsForCall []struct {
		arg1 storage.ServiceInstanceDetails
	}
	storeServiceInstanceDetailsReturns struct {
		result1 error
	}
	storeServiceInstanceDetailsReturnsOnCall map[int]struct {
		result1 error
	}
	StoreTerraformDeploymentStub        func(storage.TerraformDeployment) error
	storeTerraformDeploymentMutex       sync.RWMutex
	storeTerraformDeploymentArgsForCall []struct {
		arg1 storage.TerraformDeployment
	}
	storeTerraformDeploymentReturns struct {
		result1 error
	}
	storeTerraformDeploymentReturnsOnCall map[int]struct {
		result1 error
	}
	WriteLockFileStub        func(string) error
	writeLockFileMutex       sync.RWMutex
	writeLockFileArgsForCall []struct {
		arg1 string
	}
	writeLockFileReturns struct {
		result1 error
	}
	writeLockFileReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeStorage) CreateServiceBindingCredentials(arg1 storage.ServiceBindingCredentials) error {
	fake.createServiceBindingCredentialsMutex.Lock()
	ret, specificReturn := fake.createServiceBindingCredentialsReturnsOnCall[len(fake.createServiceBindingCredentialsArgsForCall)]
	fake.createServiceBindingCredentialsArgsForCall = append(fake.createServiceBindingCredentialsArgsForCall, struct {
		arg1 storage.ServiceBindingCredentials
	}{arg1})
	stub := fake.CreateServiceBindingCredentialsStub
	fakeReturns := fake.createServiceBindingCredentialsReturns
	fake.recordInvocation("CreateServiceBindingCredentials", []interface{}{arg1})
	fake.createServiceBindingCredentialsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) CreateServiceBindingCredentialsCallCount() int {
	fake.createServiceBindingCredentialsMutex.RLock()
	defer fake.createServiceBindingCredentialsMutex.RUnlock()
	return len(fake.createServiceBindingCredentialsArgsForCall)
}

func (fake *FakeStorage) CreateServiceBindingCredentialsCalls(stub func(storage.ServiceBindingCredentials) error) {
	fake.createServiceBindingCredentialsMutex.Lock()
	defer fake.createServiceBindingCredentialsMutex.Unlock()
	fake.CreateServiceBindingCredentialsStub = stub
}

func (fake *FakeStorage) CreateServiceBindingCredentialsArgsForCall(i int) storage.ServiceBindingCredentials {
	fake.createServiceBindingCredentialsMutex.RLock()
	defer fake.createServiceBindingCredentialsMutex.RUnlock()
	argsForCall := fake.createServiceBindingCredentialsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) CreateServiceBindingCredentialsReturns(result1 error) {
	fake.createServiceBindingCredentialsMutex.Lock()
	defer fake.createServiceBindingCredentialsMutex.Unlock()
	fake.CreateServiceBindingCredentialsStub = nil
	fake.createServiceBindingCredentialsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) CreateServiceBindingCredentialsReturnsOnCall(i int, result1 error) {
	fake.createServiceBindingCredentialsMutex.Lock()
	defer fake.createServiceBindingCredentialsMutex.Unlock()
	fake.CreateServiceBindingCredentialsStub = nil
	if fake.createServiceBindingCredentialsReturnsOnCall == nil {
		fake.createServiceBindingCredentialsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createServiceBindingCredentialsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteBindRequestDetails(arg1 string, arg2 string) error {
	fake.deleteBindRequestDetailsMutex.Lock()
	ret, specificReturn := fake.deleteBindRequestDetailsReturnsOnCall[len(fake.deleteBindRequestDetailsArgsForCall)]
	fake.deleteBindRequestDetailsArgsForCall = append(fake.deleteBindRequestDetailsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteBindRequestDetailsStub
	fakeReturns := fake.deleteBindRequestDetailsReturns
	fake.recordInvocation("DeleteBindRequestDetails", []interface{}{arg1, arg2})
	fake.deleteBindRequestDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) DeleteBindRequestDetailsCallCount() int {
	fake.deleteBindRequestDetailsMutex.RLock()
	defer fake.deleteBindRequestDetailsMutex.RUnlock()
	return len(fake.deleteBindRequestDetailsArgsForCall)
}

func (fake *FakeStorage) DeleteBindRequestDetailsCalls(stub func(string, string) error) {
	fake.deleteBindRequestDetailsMutex.Lock()
	defer fake.deleteBindRequestDetailsMutex.Unlock()
	fake.DeleteBindRequestDetailsStub = stub
}

func (fake *FakeStorage) DeleteBindRequestDetailsArgsForCall(i int) (string, string) {
	fake.deleteBindRequestDetailsMutex.RLock()
	defer fake.deleteBindRequestDetailsMutex.RUnlock()
	argsForCall := fake.deleteBindRequestDetailsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeStorage) DeleteBindRequestDetailsReturns(result1 error) {
	fake.deleteBindRequestDetailsMutex.Lock()
	defer fake.deleteBindRequestDetailsMutex.Unlock()
	fake.DeleteBindRequestDetailsStub = nil
	fake.deleteBindRequestDetailsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteBindRequestDetailsReturnsOnCall(i int, result1 error) {
	fake.deleteBindRequestDetailsMutex.Lock()
	defer fake.deleteBindRequestDetailsMutex.Unlock()
	fake.DeleteBindRequestDetailsStub = nil
	if fake.deleteBindRequestDetailsReturnsOnCall == nil {
		fake.deleteBindRequestDetailsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteBindRequestDetailsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteProvisionRequestDetails(arg1 string) error {
	fake.deleteProvisionRequestDetailsMutex.Lock()
	ret, specificReturn := fake.deleteProvisionRequestDetailsReturnsOnCall[len(fake.deleteProvisionRequestDetailsArgsForCall)]
	fake.deleteProvisionRequestDetailsArgsForCall = append(fake.deleteProvisionRequestDetailsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteProvisionRequestDetailsStub
	fakeReturns := fake.deleteProvisionRequestDetailsReturns
	fake.recordInvocation("DeleteProvisionRequestDetails", []interface{}{arg1})
	fake.deleteProvisionRequestDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) DeleteProvisionRequestDetailsCallCount() int {
	fake.deleteProvisionRequestDetailsMutex.RLock()
	defer fake.deleteProvisionRequestDetailsMutex.RUnlock()
	return len(fake.deleteProvisionRequestDetailsArgsForCall)
}

func (fake *FakeStorage) DeleteProvisionRequestDetailsCalls(stub func(string) error) {
	fake.deleteProvisionRequestDetailsMutex.Lock()
	defer fake.deleteProvisionRequestDetailsMutex.Unlock()
	fake.DeleteProvisionRequestDetailsStub = stub
}

func (fake *FakeStorage) DeleteProvisionRequestDetailsArgsForCall(i int) string {
	fake.deleteProvisionRequestDetailsMutex.RLock()
	defer fake.deleteProvisionRequestDetailsMutex.RUnlock()
	argsForCall := fake.deleteProvisionRequestDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) DeleteProvisionRequestDetailsReturns(result1 error) {
	fake.deleteProvisionRequestDetailsMutex.Lock()
	defer fake.deleteProvisionRequestDetailsMutex.Unlock()
	fake.DeleteProvisionRequestDetailsStub = nil
	fake.deleteProvisionRequestDetailsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteProvisionRequestDetailsReturnsOnCall(i int, result1 error) {
	fake.deleteProvisionRequestDetailsMutex.Lock()
	defer fake.deleteProvisionRequestDetailsMutex.Unlock()
	fake.DeleteProvisionRequestDetailsStub = nil
	if fake.deleteProvisionRequestDetailsReturnsOnCall == nil {
		fake.deleteProvisionRequestDetailsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteProvisionRequestDetailsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteServiceBindingCredentials(arg1 string, arg2 string) error {
	fake.deleteServiceBindingCredentialsMutex.Lock()
	ret, specificReturn := fake.deleteServiceBindingCredentialsReturnsOnCall[len(fake.deleteServiceBindingCredentialsArgsForCall)]
	fake.deleteServiceBindingCredentialsArgsForCall = append(fake.deleteServiceBindingCredentialsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteServiceBindingCredentialsStub
	fakeReturns := fake.deleteServiceBindingCredentialsReturns
	fake.recordInvocation("DeleteServiceBindingCredentials", []interface{}{arg1, arg2})
	fake.deleteServiceBindingCredentialsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) DeleteServiceBindingCredentialsCallCount() int {
	fake.deleteServiceBindingCredentialsMutex.RLock()
	defer fake.deleteServiceBindingCredentialsMutex.RUnlock()
	return len(fake.deleteServiceBindingCredentialsArgsForCall)
}

func (fake *FakeStorage) DeleteServiceBindingCredentialsCalls(stub func(string, string) error) {
	fake.deleteServiceBindingCredentialsMutex.Lock()
	defer fake.deleteServiceBindingCredentialsMutex.Unlock()
	fake.DeleteServiceBindingCredentialsStub = stub
}

func (fake *FakeStorage) DeleteServiceBindingCredentialsArgsForCall(i int) (string, string) {
	fake.deleteServiceBindingCredentialsMutex.RLock()
	defer fake.deleteServiceBindingCredentialsMutex.RUnlock()
	argsForCall := fake.deleteServiceBindingCredentialsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeStorage) DeleteServiceBindingCredentialsReturns(result1 error) {
	fake.deleteServiceBindingCredentialsMutex.Lock()
	defer fake.deleteServiceBindingCredentialsMutex.Unlock()
	fake.DeleteServiceBindingCredentialsStub = nil
	fake.deleteServiceBindingCredentialsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteServiceBindingCredentialsReturnsOnCall(i int, result1 error) {
	fake.deleteServiceBindingCredentialsMutex.Lock()
	defer fake.deleteServiceBindingCredentialsMutex.Unlock()
	fake.DeleteServiceBindingCredentialsStub = nil
	if fake.deleteServiceBindingCredentialsReturnsOnCall == nil {
		fake.deleteServiceBindingCredentialsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteServiceBindingCredentialsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteServiceInstanceDetails(arg1 string) error {
	fake.deleteServiceInstanceDetailsMutex.Lock()
	ret, specificReturn := fake.deleteServiceInstanceDetailsReturnsOnCall[len(fake.deleteServiceInstanceDetailsArgsForCall)]
	fake.deleteServiceInstanceDetailsArgsForCall = append(fake.deleteServiceInstanceDetailsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteServiceInstanceDetailsStub
	fakeReturns := fake.deleteServiceInstanceDetailsReturns
	fake.recordInvocation("DeleteServiceInstanceDetails", []interface{}{arg1})
	fake.deleteServiceInstanceDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) DeleteServiceInstanceDetailsCallCount() int {
	fake.deleteServiceInstanceDetailsMutex.RLock()
	defer fake.deleteServiceInstanceDetailsMutex.RUnlock()
	return len(fake.deleteServiceInstanceDetailsArgsForCall)
}

func (fake *FakeStorage) DeleteServiceInstanceDetailsCalls(stub func(string) error) {
	fake.deleteServiceInstanceDetailsMutex.Lock()
	defer fake.deleteServiceInstanceDetailsMutex.Unlock()
	fake.DeleteServiceInstanceDetailsStub = stub
}

func (fake *FakeStorage) DeleteServiceInstanceDetailsArgsForCall(i int) string {
	fake.deleteServiceInstanceDetailsMutex.RLock()
	defer fake.deleteServiceInstanceDetailsMutex.RUnlock()
	argsForCall := fake.deleteServiceInstanceDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) DeleteServiceInstanceDetailsReturns(result1 error) {
	fake.deleteServiceInstanceDetailsMutex.Lock()
	defer fake.deleteServiceInstanceDetailsMutex.Unlock()
	fake.DeleteServiceInstanceDetailsStub = nil
	fake.deleteServiceInstanceDetailsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteServiceInstanceDetailsReturnsOnCall(i int, result1 error) {
	fake.deleteServiceInstanceDetailsMutex.Lock()
	defer fake.deleteServiceInstanceDetailsMutex.Unlock()
	fake.DeleteServiceInstanceDetailsStub = nil
	if fake.deleteServiceInstanceDetailsReturnsOnCall == nil {
		fake.deleteServiceInstanceDetailsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteServiceInstanceDetailsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteTerraformDeployment(arg1 string) error {
	fake.deleteTerraformDeploymentMutex.Lock()
	ret, specificReturn := fake.deleteTerraformDeploymentReturnsOnCall[len(fake.deleteTerraformDeploymentArgsForCall)]
	fake.deleteTerraformDeploymentArgsForCall = append(fake.deleteTerraformDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.DeleteTerraformDeploymentStub
	fakeReturns := fake.deleteTerraformDeploymentReturns
	fake.recordInvocation("DeleteTerraformDeployment", []interface{}{arg1})
	fake.deleteTerraformDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) DeleteTerraformDeploymentCallCount() int {
	fake.deleteTerraformDeploymentMutex.RLock()
	defer fake.deleteTerraformDeploymentMutex.RUnlock()
	return len(fake.deleteTerraformDeploymentArgsForCall)
}

func (fake *FakeStorage) DeleteTerraformDeploymentCalls(stub func(string) error) {
	fake.deleteTerraformDeploymentMutex.Lock()
	defer fake.deleteTerraformDeploymentMutex.Unlock()
	fake.DeleteTerraformDeploymentStub = stub
}

func (fake *FakeStorage) DeleteTerraformDeploymentArgsForCall(i int) string {
	fake.deleteTerraformDeploymentMutex.RLock()
	defer fake.deleteTerraformDeploymentMutex.RUnlock()
	argsForCall := fake.deleteTerraformDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) DeleteTerraformDeploymentReturns(result1 error) {
	fake.deleteTerraformDeploymentMutex.Lock()
	defer fake.deleteTerraformDeploymentMutex.Unlock()
	fake.DeleteTerraformDeploymentStub = nil
	fake.deleteTerraformDeploymentReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) DeleteTerraformDeploymentReturnsOnCall(i int, result1 error) {
	fake.deleteTerraformDeploymentMutex.Lock()
	defer fake.deleteTerraformDeploymentMutex.Unlock()
	fake.DeleteTerraformDeploymentStub = nil
	if fake.deleteTerraformDeploymentReturnsOnCall == nil {
		fake.deleteTerraformDeploymentReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteTerraformDeploymentReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) ExistsServiceBindingCredentials(arg1 string, arg2 string) (bool, error) {
	fake.existsServiceBindingCredentialsMutex.Lock()
	ret, specificReturn := fake.existsServiceBindingCredentialsReturnsOnCall[len(fake.existsServiceBindingCredentialsArgsForCall)]
	fake.existsServiceBindingCredentialsArgsForCall = append(fake.existsServiceBindingCredentialsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.ExistsServiceBindingCredentialsStub
	fakeReturns := fake.existsServiceBindingCredentialsReturns
	fake.recordInvocation("ExistsServiceBindingCredentials", []interface{}{arg1, arg2})
	fake.existsServiceBindingCredentialsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) ExistsServiceBindingCredentialsCallCount() int {
	fake.existsServiceBindingCredentialsMutex.RLock()
	defer fake.existsServiceBindingCredentialsMutex.RUnlock()
	return len(fake.existsServiceBindingCredentialsArgsForCall)
}

func (fake *FakeStorage) ExistsServiceBindingCredentialsCalls(stub func(string, string) (bool, error)) {
	fake.existsServiceBindingCredentialsMutex.Lock()
	defer fake.existsServiceBindingCredentialsMutex.Unlock()
	fake.ExistsServiceBindingCredentialsStub = stub
}

func (fake *FakeStorage) ExistsServiceBindingCredentialsArgsForCall(i int) (string, string) {
	fake.existsServiceBindingCredentialsMutex.RLock()
	defer fake.existsServiceBindingCredentialsMutex.RUnlock()
	argsForCall := fake.existsServiceBindingCredentialsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeStorage) ExistsServiceBindingCredentialsReturns(result1 bool, result2 error) {
	fake.existsServiceBindingCredentialsMutex.Lock()
	defer fake.existsServiceBindingCredentialsMutex.Unlock()
	fake.ExistsServiceBindingCredentialsStub = nil
	fake.existsServiceBindingCredentialsReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) ExistsServiceBindingCredentialsReturnsOnCall(i int, result1 bool, result2 error) {
	fake.existsServiceBindingCredentialsMutex.Lock()
	defer fake.existsServiceBindingCredentialsMutex.Unlock()
	fake.ExistsServiceBindingCredentialsStub = nil
	if fake.existsServiceBindingCredentialsReturnsOnCall == nil {
		fake.existsServiceBindingCredentialsReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.existsServiceBindingCredentialsReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) ExistsServiceInstanceDetails(arg1 string) (bool, error) {
	fake.existsServiceInstanceDetailsMutex.Lock()
	ret, specificReturn := fake.existsServiceInstanceDetailsReturnsOnCall[len(fake.existsServiceInstanceDetailsArgsForCall)]
	fake.existsServiceInstanceDetailsArgsForCall = append(fake.existsServiceInstanceDetailsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ExistsServiceInstanceDetailsStub
	fakeReturns := fake.existsServiceInstanceDetailsReturns
	fake.recordInvocation("ExistsServiceInstanceDetails", []interface{}{arg1})
	fake.existsServiceInstanceDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) ExistsServiceInstanceDetailsCallCount() int {
	fake.existsServiceInstanceDetailsMutex.RLock()
	defer fake.existsServiceInstanceDetailsMutex.RUnlock()
	return len(fake.existsServiceInstanceDetailsArgsForCall)
}

func (fake *FakeStorage) ExistsServiceInstanceDetailsCalls(stub func(string) (bool, error)) {
	fake.existsServiceInstanceDetailsMutex.Lock()
	defer fake.existsServiceInstanceDetailsMutex.Unlock()
	fake.ExistsServiceInstanceDetailsStub = stub
}

func (fake *FakeStorage) ExistsServiceInstanceDetailsArgsForCall(i int) string {
	fake.existsServiceInstanceDetailsMutex.RLock()
	defer fake.existsServiceInstanceDetailsMutex.RUnlock()
	argsForCall := fake.existsServiceInstanceDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) ExistsServiceInstanceDetailsReturns(result1 bool, result2 error) {
	fake.existsServiceInstanceDetailsMutex.Lock()
	defer fake.existsServiceInstanceDetailsMutex.Unlock()
	fake.ExistsServiceInstanceDetailsStub = nil
	fake.existsServiceInstanceDetailsReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) ExistsServiceInstanceDetailsReturnsOnCall(i int, result1 bool, result2 error) {
	fake.existsServiceInstanceDetailsMutex.Lock()
	defer fake.existsServiceInstanceDetailsMutex.Unlock()
	fake.ExistsServiceInstanceDetailsStub = nil
	if fake.existsServiceInstanceDetailsReturnsOnCall == nil {
		fake.existsServiceInstanceDetailsReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.existsServiceInstanceDetailsReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) ExistsTerraformDeployment(arg1 string) (bool, error) {
	fake.existsTerraformDeploymentMutex.Lock()
	ret, specificReturn := fake.existsTerraformDeploymentReturnsOnCall[len(fake.existsTerraformDeploymentArgsForCall)]
	fake.existsTerraformDeploymentArgsForCall = append(fake.existsTerraformDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.ExistsTerraformDeploymentStub
	fakeReturns := fake.existsTerraformDeploymentReturns
	fake.recordInvocation("ExistsTerraformDeployment", []interface{}{arg1})
	fake.existsTerraformDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) ExistsTerraformDeploymentCallCount() int {
	fake.existsTerraformDeploymentMutex.RLock()
	defer fake.existsTerraformDeploymentMutex.RUnlock()
	return len(fake.existsTerraformDeploymentArgsForCall)
}

func (fake *FakeStorage) ExistsTerraformDeploymentCalls(stub func(string) (bool, error)) {
	fake.existsTerraformDeploymentMutex.Lock()
	defer fake.existsTerraformDeploymentMutex.Unlock()
	fake.ExistsTerraformDeploymentStub = stub
}

func (fake *FakeStorage) ExistsTerraformDeploymentArgsForCall(i int) string {
	fake.existsTerraformDeploymentMutex.RLock()
	defer fake.existsTerraformDeploymentMutex.RUnlock()
	argsForCall := fake.existsTerraformDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) ExistsTerraformDeploymentReturns(result1 bool, result2 error) {
	fake.existsTerraformDeploymentMutex.Lock()
	defer fake.existsTerraformDeploymentMutex.Unlock()
	fake.ExistsTerraformDeploymentStub = nil
	fake.existsTerraformDeploymentReturns = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) ExistsTerraformDeploymentReturnsOnCall(i int, result1 bool, result2 error) {
	fake.existsTerraformDeploymentMutex.Lock()
	defer fake.existsTerraformDeploymentMutex.Unlock()
	fake.ExistsTerraformDeploymentStub = nil
	if fake.existsTerraformDeploymentReturnsOnCall == nil {
		fake.existsTerraformDeploymentReturnsOnCall = make(map[int]struct {
			result1 bool
			result2 error
		})
	}
	fake.existsTerraformDeploymentReturnsOnCall[i] = struct {
		result1 bool
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetBindRequestDetails(arg1 string, arg2 string) (storage.JSONObject, error) {
	fake.getBindRequestDetailsMutex.Lock()
	ret, specificReturn := fake.getBindRequestDetailsReturnsOnCall[len(fake.getBindRequestDetailsArgsForCall)]
	fake.getBindRequestDetailsArgsForCall = append(fake.getBindRequestDetailsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetBindRequestDetailsStub
	fakeReturns := fake.getBindRequestDetailsReturns
	fake.recordInvocation("GetBindRequestDetails", []interface{}{arg1, arg2})
	fake.getBindRequestDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) GetBindRequestDetailsCallCount() int {
	fake.getBindRequestDetailsMutex.RLock()
	defer fake.getBindRequestDetailsMutex.RUnlock()
	return len(fake.getBindRequestDetailsArgsForCall)
}

func (fake *FakeStorage) GetBindRequestDetailsCalls(stub func(string, string) (storage.JSONObject, error)) {
	fake.getBindRequestDetailsMutex.Lock()
	defer fake.getBindRequestDetailsMutex.Unlock()
	fake.GetBindRequestDetailsStub = stub
}

func (fake *FakeStorage) GetBindRequestDetailsArgsForCall(i int) (string, string) {
	fake.getBindRequestDetailsMutex.RLock()
	defer fake.getBindRequestDetailsMutex.RUnlock()
	argsForCall := fake.getBindRequestDetailsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeStorage) GetBindRequestDetailsReturns(result1 storage.JSONObject, result2 error) {
	fake.getBindRequestDetailsMutex.Lock()
	defer fake.getBindRequestDetailsMutex.Unlock()
	fake.GetBindRequestDetailsStub = nil
	fake.getBindRequestDetailsReturns = struct {
		result1 storage.JSONObject
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetBindRequestDetailsReturnsOnCall(i int, result1 storage.JSONObject, result2 error) {
	fake.getBindRequestDetailsMutex.Lock()
	defer fake.getBindRequestDetailsMutex.Unlock()
	fake.GetBindRequestDetailsStub = nil
	if fake.getBindRequestDetailsReturnsOnCall == nil {
		fake.getBindRequestDetailsReturnsOnCall = make(map[int]struct {
			result1 storage.JSONObject
			result2 error
		})
	}
	fake.getBindRequestDetailsReturnsOnCall[i] = struct {
		result1 storage.JSONObject
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetProvisionRequestDetails(arg1 string) (storage.JSONObject, error) {
	fake.getProvisionRequestDetailsMutex.Lock()
	ret, specificReturn := fake.getProvisionRequestDetailsReturnsOnCall[len(fake.getProvisionRequestDetailsArgsForCall)]
	fake.getProvisionRequestDetailsArgsForCall = append(fake.getProvisionRequestDetailsArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetProvisionRequestDetailsStub
	fakeReturns := fake.getProvisionRequestDetailsReturns
	fake.recordInvocation("GetProvisionRequestDetails", []interface{}{arg1})
	fake.getProvisionRequestDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) GetProvisionRequestDetailsCallCount() int {
	fake.getProvisionRequestDetailsMutex.RLock()
	defer fake.getProvisionRequestDetailsMutex.RUnlock()
	return len(fake.getProvisionRequestDetailsArgsForCall)
}

func (fake *FakeStorage) GetProvisionRequestDetailsCalls(stub func(string) (storage.JSONObject, error)) {
	fake.getProvisionRequestDetailsMutex.Lock()
	defer fake.getProvisionRequestDetailsMutex.Unlock()
	fake.GetProvisionRequestDetailsStub = stub
}

func (fake *FakeStorage) GetProvisionRequestDetailsArgsForCall(i int) string {
	fake.getProvisionRequestDetailsMutex.RLock()
	defer fake.getProvisionRequestDetailsMutex.RUnlock()
	argsForCall := fake.getProvisionRequestDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) GetProvisionRequestDetailsReturns(result1 storage.JSONObject, result2 error) {
	fake.getProvisionRequestDetailsMutex.Lock()
	defer fake.getProvisionRequestDetailsMutex.Unlock()
	fake.GetProvisionRequestDetailsStub = nil
	fake.getProvisionRequestDetailsReturns = struct {
		result1 storage.JSONObject
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetProvisionRequestDetailsReturnsOnCall(i int, result1 storage.JSONObject, result2 error) {
	fake.getProvisionRequestDetailsMutex.Lock()
	defer fake.getProvisionRequestDetailsMutex.Unlock()
	fake.GetProvisionRequestDetailsStub = nil
	if fake.getProvisionRequestDetailsReturnsOnCall == nil {
		fake.getProvisionRequestDetailsReturnsOnCall = make(map[int]struct {
			result1 storage.JSONObject
			result2 error
		})
	}
	fake.getProvisionRequestDetailsReturnsOnCall[i] = struct {
		result1 storage.JSONObject
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetServiceBindingCredentials(arg1 string, arg2 string) (storage.ServiceBindingCredentials, error) {
	fake.getServiceBindingCredentialsMutex.Lock()
	ret, specificReturn := fake.getServiceBindingCredentialsReturnsOnCall[len(fake.getServiceBindingCredentialsArgsForCall)]
	fake.getServiceBindingCredentialsArgsForCall = append(fake.getServiceBindingCredentialsArgsForCall, struct {
		arg1 string
		arg2 string
	}{arg1, arg2})
	stub := fake.GetServiceBindingCredentialsStub
	fakeReturns := fake.getServiceBindingCredentialsReturns
	fake.recordInvocation("GetServiceBindingCredentials", []interface{}{arg1, arg2})
	fake.getServiceBindingCredentialsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) GetServiceBindingCredentialsCallCount() int {
	fake.getServiceBindingCredentialsMutex.RLock()
	defer fake.getServiceBindingCredentialsMutex.RUnlock()
	return len(fake.getServiceBindingCredentialsArgsForCall)
}

func (fake *FakeStorage) GetServiceBindingCredentialsCalls(stub func(string, string) (storage.ServiceBindingCredentials, error)) {
	fake.getServiceBindingCredentialsMutex.Lock()
	defer fake.getServiceBindingCredentialsMutex.Unlock()
	fake.GetServiceBindingCredentialsStub = stub
}

func (fake *FakeStorage) GetServiceBindingCredentialsArgsForCall(i int) (string, string) {
	fake.getServiceBindingCredentialsMutex.RLock()
	defer fake.getServiceBindingCredentialsMutex.RUnlock()
	argsForCall := fake.getServiceBindingCredentialsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeStorage) GetServiceBindingCredentialsReturns(result1 storage.ServiceBindingCredentials, result2 error) {
	fake.getServiceBindingCredentialsMutex.Lock()
	defer fake.getServiceBindingCredentialsMutex.Unlock()
	fake.GetServiceBindingCredentialsStub = nil
	fake.getServiceBindingCredentialsReturns = struct {
		result1 storage.ServiceBindingCredentials
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetServiceBindingCredentialsReturnsOnCall(i int, result1 storage.ServiceBindingCredentials, result2 error) {
	fake.getServiceBindingCredentialsMutex.Lock()
	defer fake.getServiceBindingCredentialsMutex.Unlock()
	fake.GetServiceBindingCredentialsStub = nil
	if fake.getServiceBindingCredentialsReturnsOnCall == nil {
		fake.getServiceBindingCredentialsReturnsOnCall = make(map[int]struct {
			result1 storage.ServiceBindingCredentials
			result2 error
		})
	}
	fake.getServiceBindingCredentialsReturnsOnCall[i] = struct {
		result1 storage.ServiceBindingCredentials
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetServiceBindingIDsForServiceInstance(arg1 string) ([]string, error) {
	fake.getServiceBindingIDsForServiceInstanceMutex.Lock()
	ret, specificReturn := fake.getServiceBindingIDsForServiceInstanceReturnsOnCall[len(fake.getServiceBindingIDsForServiceInstanceArgsForCall)]
	fake.getServiceBindingIDsForServiceInstanceArgsForCall = append(fake.getServiceBindingIDsForServiceInstanceArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetServiceBindingIDsForServiceInstanceStub
	fakeReturns := fake.getServiceBindingIDsForServiceInstanceReturns
	fake.recordInvocation("GetServiceBindingIDsForServiceInstance", []interface{}{arg1})
	fake.getServiceBindingIDsForServiceInstanceMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) GetServiceBindingIDsForServiceInstanceCallCount() int {
	fake.getServiceBindingIDsForServiceInstanceMutex.RLock()
	defer fake.getServiceBindingIDsForServiceInstanceMutex.RUnlock()
	return len(fake.getServiceBindingIDsForServiceInstanceArgsForCall)
}

func (fake *FakeStorage) GetServiceBindingIDsForServiceInstanceCalls(stub func(string) ([]string, error)) {
	fake.getServiceBindingIDsForServiceInstanceMutex.Lock()
	defer fake.getServiceBindingIDsForServiceInstanceMutex.Unlock()
	fake.GetServiceBindingIDsForServiceInstanceStub = stub
}

func (fake *FakeStorage) GetServiceBindingIDsForServiceInstanceArgsForCall(i int) string {
	fake.getServiceBindingIDsForServiceInstanceMutex.RLock()
	defer fake.getServiceBindingIDsForServiceInstanceMutex.RUnlock()
	argsForCall := fake.getServiceBindingIDsForServiceInstanceArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) GetServiceBindingIDsForServiceInstanceReturns(result1 []string, result2 error) {
	fake.getServiceBindingIDsForServiceInstanceMutex.Lock()
	defer fake.getServiceBindingIDsForServiceInstanceMutex.Unlock()
	fake.GetServiceBindingIDsForServiceInstanceStub = nil
	fake.getServiceBindingIDsForServiceInstanceReturns = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetServiceBindingIDsForServiceInstanceReturnsOnCall(i int, result1 []string, result2 error) {
	fake.getServiceBindingIDsForServiceInstanceMutex.Lock()
	defer fake.getServiceBindingIDsForServiceInstanceMutex.Unlock()
	fake.GetServiceBindingIDsForServiceInstanceStub = nil
	if fake.getServiceBindingIDsForServiceInstanceReturnsOnCall == nil {
		fake.getServiceBindingIDsForServiceInstanceReturnsOnCall = make(map[int]struct {
			result1 []string
			result2 error
		})
	}
	fake.getServiceBindingIDsForServiceInstanceReturnsOnCall[i] = struct {
		result1 []string
		result2 error
	}{result1, result2}
}

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

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

func (fake *FakeStorage) GetServiceInstanceDetailsCalls(stub func(string) (storage.ServiceInstanceDetails, error)) {
	fake.getServiceInstanceDetailsMutex.Lock()
	defer fake.getServiceInstanceDetailsMutex.Unlock()
	fake.GetServiceInstanceDetailsStub = stub
}

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

func (fake *FakeStorage) GetServiceInstanceDetailsReturns(result1 storage.ServiceInstanceDetails, result2 error) {
	fake.getServiceInstanceDetailsMutex.Lock()
	defer fake.getServiceInstanceDetailsMutex.Unlock()
	fake.GetServiceInstanceDetailsStub = nil
	fake.getServiceInstanceDetailsReturns = struct {
		result1 storage.ServiceInstanceDetails
		result2 error
	}{result1, result2}
}

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

func (fake *FakeStorage) GetTerraformDeployment(arg1 string) (storage.TerraformDeployment, error) {
	fake.getTerraformDeploymentMutex.Lock()
	ret, specificReturn := fake.getTerraformDeploymentReturnsOnCall[len(fake.getTerraformDeploymentArgsForCall)]
	fake.getTerraformDeploymentArgsForCall = append(fake.getTerraformDeploymentArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.GetTerraformDeploymentStub
	fakeReturns := fake.getTerraformDeploymentReturns
	fake.recordInvocation("GetTerraformDeployment", []interface{}{arg1})
	fake.getTerraformDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeStorage) GetTerraformDeploymentCallCount() int {
	fake.getTerraformDeploymentMutex.RLock()
	defer fake.getTerraformDeploymentMutex.RUnlock()
	return len(fake.getTerraformDeploymentArgsForCall)
}

func (fake *FakeStorage) GetTerraformDeploymentCalls(stub func(string) (storage.TerraformDeployment, error)) {
	fake.getTerraformDeploymentMutex.Lock()
	defer fake.getTerraformDeploymentMutex.Unlock()
	fake.GetTerraformDeploymentStub = stub
}

func (fake *FakeStorage) GetTerraformDeploymentArgsForCall(i int) string {
	fake.getTerraformDeploymentMutex.RLock()
	defer fake.getTerraformDeploymentMutex.RUnlock()
	argsForCall := fake.getTerraformDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) GetTerraformDeploymentReturns(result1 storage.TerraformDeployment, result2 error) {
	fake.getTerraformDeploymentMutex.Lock()
	defer fake.getTerraformDeploymentMutex.Unlock()
	fake.GetTerraformDeploymentStub = nil
	fake.getTerraformDeploymentReturns = struct {
		result1 storage.TerraformDeployment
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) GetTerraformDeploymentReturnsOnCall(i int, result1 storage.TerraformDeployment, result2 error) {
	fake.getTerraformDeploymentMutex.Lock()
	defer fake.getTerraformDeploymentMutex.Unlock()
	fake.GetTerraformDeploymentStub = nil
	if fake.getTerraformDeploymentReturnsOnCall == nil {
		fake.getTerraformDeploymentReturnsOnCall = make(map[int]struct {
			result1 storage.TerraformDeployment
			result2 error
		})
	}
	fake.getTerraformDeploymentReturnsOnCall[i] = struct {
		result1 storage.TerraformDeployment
		result2 error
	}{result1, result2}
}

func (fake *FakeStorage) RemoveLockFile(arg1 string) error {
	fake.removeLockFileMutex.Lock()
	ret, specificReturn := fake.removeLockFileReturnsOnCall[len(fake.removeLockFileArgsForCall)]
	fake.removeLockFileArgsForCall = append(fake.removeLockFileArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.RemoveLockFileStub
	fakeReturns := fake.removeLockFileReturns
	fake.recordInvocation("RemoveLockFile", []interface{}{arg1})
	fake.removeLockFileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) RemoveLockFileCallCount() int {
	fake.removeLockFileMutex.RLock()
	defer fake.removeLockFileMutex.RUnlock()
	return len(fake.removeLockFileArgsForCall)
}

func (fake *FakeStorage) RemoveLockFileCalls(stub func(string) error) {
	fake.removeLockFileMutex.Lock()
	defer fake.removeLockFileMutex.Unlock()
	fake.RemoveLockFileStub = stub
}

func (fake *FakeStorage) RemoveLockFileArgsForCall(i int) string {
	fake.removeLockFileMutex.RLock()
	defer fake.removeLockFileMutex.RUnlock()
	argsForCall := fake.removeLockFileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) RemoveLockFileReturns(result1 error) {
	fake.removeLockFileMutex.Lock()
	defer fake.removeLockFileMutex.Unlock()
	fake.RemoveLockFileStub = nil
	fake.removeLockFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) RemoveLockFileReturnsOnCall(i int, result1 error) {
	fake.removeLockFileMutex.Lock()
	defer fake.removeLockFileMutex.Unlock()
	fake.RemoveLockFileStub = nil
	if fake.removeLockFileReturnsOnCall == nil {
		fake.removeLockFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.removeLockFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreBindRequestDetails(arg1 storage.BindRequestDetails) error {
	fake.storeBindRequestDetailsMutex.Lock()
	ret, specificReturn := fake.storeBindRequestDetailsReturnsOnCall[len(fake.storeBindRequestDetailsArgsForCall)]
	fake.storeBindRequestDetailsArgsForCall = append(fake.storeBindRequestDetailsArgsForCall, struct {
		arg1 storage.BindRequestDetails
	}{arg1})
	stub := fake.StoreBindRequestDetailsStub
	fakeReturns := fake.storeBindRequestDetailsReturns
	fake.recordInvocation("StoreBindRequestDetails", []interface{}{arg1})
	fake.storeBindRequestDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) StoreBindRequestDetailsCallCount() int {
	fake.storeBindRequestDetailsMutex.RLock()
	defer fake.storeBindRequestDetailsMutex.RUnlock()
	return len(fake.storeBindRequestDetailsArgsForCall)
}

func (fake *FakeStorage) StoreBindRequestDetailsCalls(stub func(storage.BindRequestDetails) error) {
	fake.storeBindRequestDetailsMutex.Lock()
	defer fake.storeBindRequestDetailsMutex.Unlock()
	fake.StoreBindRequestDetailsStub = stub
}

func (fake *FakeStorage) StoreBindRequestDetailsArgsForCall(i int) storage.BindRequestDetails {
	fake.storeBindRequestDetailsMutex.RLock()
	defer fake.storeBindRequestDetailsMutex.RUnlock()
	argsForCall := fake.storeBindRequestDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) StoreBindRequestDetailsReturns(result1 error) {
	fake.storeBindRequestDetailsMutex.Lock()
	defer fake.storeBindRequestDetailsMutex.Unlock()
	fake.StoreBindRequestDetailsStub = nil
	fake.storeBindRequestDetailsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreBindRequestDetailsReturnsOnCall(i int, result1 error) {
	fake.storeBindRequestDetailsMutex.Lock()
	defer fake.storeBindRequestDetailsMutex.Unlock()
	fake.StoreBindRequestDetailsStub = nil
	if fake.storeBindRequestDetailsReturnsOnCall == nil {
		fake.storeBindRequestDetailsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.storeBindRequestDetailsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreProvisionRequestDetails(arg1 string, arg2 storage.JSONObject) error {
	fake.storeProvisionRequestDetailsMutex.Lock()
	ret, specificReturn := fake.storeProvisionRequestDetailsReturnsOnCall[len(fake.storeProvisionRequestDetailsArgsForCall)]
	fake.storeProvisionRequestDetailsArgsForCall = append(fake.storeProvisionRequestDetailsArgsForCall, struct {
		arg1 string
		arg2 storage.JSONObject
	}{arg1, arg2})
	stub := fake.StoreProvisionRequestDetailsStub
	fakeReturns := fake.storeProvisionRequestDetailsReturns
	fake.recordInvocation("StoreProvisionRequestDetails", []interface{}{arg1, arg2})
	fake.storeProvisionRequestDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) StoreProvisionRequestDetailsCallCount() int {
	fake.storeProvisionRequestDetailsMutex.RLock()
	defer fake.storeProvisionRequestDetailsMutex.RUnlock()
	return len(fake.storeProvisionRequestDetailsArgsForCall)
}

func (fake *FakeStorage) StoreProvisionRequestDetailsCalls(stub func(string, storage.JSONObject) error) {
	fake.storeProvisionRequestDetailsMutex.Lock()
	defer fake.storeProvisionRequestDetailsMutex.Unlock()
	fake.StoreProvisionRequestDetailsStub = stub
}

func (fake *FakeStorage) StoreProvisionRequestDetailsArgsForCall(i int) (string, storage.JSONObject) {
	fake.storeProvisionRequestDetailsMutex.RLock()
	defer fake.storeProvisionRequestDetailsMutex.RUnlock()
	argsForCall := fake.storeProvisionRequestDetailsArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeStorage) StoreProvisionRequestDetailsReturns(result1 error) {
	fake.storeProvisionRequestDetailsMutex.Lock()
	defer fake.storeProvisionRequestDetailsMutex.Unlock()
	fake.StoreProvisionRequestDetailsStub = nil
	fake.storeProvisionRequestDetailsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreProvisionRequestDetailsReturnsOnCall(i int, result1 error) {
	fake.storeProvisionRequestDetailsMutex.Lock()
	defer fake.storeProvisionRequestDetailsMutex.Unlock()
	fake.StoreProvisionRequestDetailsStub = nil
	if fake.storeProvisionRequestDetailsReturnsOnCall == nil {
		fake.storeProvisionRequestDetailsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.storeProvisionRequestDetailsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreServiceInstanceDetails(arg1 storage.ServiceInstanceDetails) error {
	fake.storeServiceInstanceDetailsMutex.Lock()
	ret, specificReturn := fake.storeServiceInstanceDetailsReturnsOnCall[len(fake.storeServiceInstanceDetailsArgsForCall)]
	fake.storeServiceInstanceDetailsArgsForCall = append(fake.storeServiceInstanceDetailsArgsForCall, struct {
		arg1 storage.ServiceInstanceDetails
	}{arg1})
	stub := fake.StoreServiceInstanceDetailsStub
	fakeReturns := fake.storeServiceInstanceDetailsReturns
	fake.recordInvocation("StoreServiceInstanceDetails", []interface{}{arg1})
	fake.storeServiceInstanceDetailsMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) StoreServiceInstanceDetailsCallCount() int {
	fake.storeServiceInstanceDetailsMutex.RLock()
	defer fake.storeServiceInstanceDetailsMutex.RUnlock()
	return len(fake.storeServiceInstanceDetailsArgsForCall)
}

func (fake *FakeStorage) StoreServiceInstanceDetailsCalls(stub func(storage.ServiceInstanceDetails) error) {
	fake.storeServiceInstanceDetailsMutex.Lock()
	defer fake.storeServiceInstanceDetailsMutex.Unlock()
	fake.StoreServiceInstanceDetailsStub = stub
}

func (fake *FakeStorage) StoreServiceInstanceDetailsArgsForCall(i int) storage.ServiceInstanceDetails {
	fake.storeServiceInstanceDetailsMutex.RLock()
	defer fake.storeServiceInstanceDetailsMutex.RUnlock()
	argsForCall := fake.storeServiceInstanceDetailsArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) StoreServiceInstanceDetailsReturns(result1 error) {
	fake.storeServiceInstanceDetailsMutex.Lock()
	defer fake.storeServiceInstanceDetailsMutex.Unlock()
	fake.StoreServiceInstanceDetailsStub = nil
	fake.storeServiceInstanceDetailsReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreServiceInstanceDetailsReturnsOnCall(i int, result1 error) {
	fake.storeServiceInstanceDetailsMutex.Lock()
	defer fake.storeServiceInstanceDetailsMutex.Unlock()
	fake.StoreServiceInstanceDetailsStub = nil
	if fake.storeServiceInstanceDetailsReturnsOnCall == nil {
		fake.storeServiceInstanceDetailsReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.storeServiceInstanceDetailsReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreTerraformDeployment(arg1 storage.TerraformDeployment) error {
	fake.storeTerraformDeploymentMutex.Lock()
	ret, specificReturn := fake.storeTerraformDeploymentReturnsOnCall[len(fake.storeTerraformDeploymentArgsForCall)]
	fake.storeTerraformDeploymentArgsForCall = append(fake.storeTerraformDeploymentArgsForCall, struct {
		arg1 storage.TerraformDeployment
	}{arg1})
	stub := fake.StoreTerraformDeploymentStub
	fakeReturns := fake.storeTerraformDeploymentReturns
	fake.recordInvocation("StoreTerraformDeployment", []interface{}{arg1})
	fake.storeTerraformDeploymentMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) StoreTerraformDeploymentCallCount() int {
	fake.storeTerraformDeploymentMutex.RLock()
	defer fake.storeTerraformDeploymentMutex.RUnlock()
	return len(fake.storeTerraformDeploymentArgsForCall)
}

func (fake *FakeStorage) StoreTerraformDeploymentCalls(stub func(storage.TerraformDeployment) error) {
	fake.storeTerraformDeploymentMutex.Lock()
	defer fake.storeTerraformDeploymentMutex.Unlock()
	fake.StoreTerraformDeploymentStub = stub
}

func (fake *FakeStorage) StoreTerraformDeploymentArgsForCall(i int) storage.TerraformDeployment {
	fake.storeTerraformDeploymentMutex.RLock()
	defer fake.storeTerraformDeploymentMutex.RUnlock()
	argsForCall := fake.storeTerraformDeploymentArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) StoreTerraformDeploymentReturns(result1 error) {
	fake.storeTerraformDeploymentMutex.Lock()
	defer fake.storeTerraformDeploymentMutex.Unlock()
	fake.StoreTerraformDeploymentStub = nil
	fake.storeTerraformDeploymentReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) StoreTerraformDeploymentReturnsOnCall(i int, result1 error) {
	fake.storeTerraformDeploymentMutex.Lock()
	defer fake.storeTerraformDeploymentMutex.Unlock()
	fake.StoreTerraformDeploymentStub = nil
	if fake.storeTerraformDeploymentReturnsOnCall == nil {
		fake.storeTerraformDeploymentReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.storeTerraformDeploymentReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) WriteLockFile(arg1 string) error {
	fake.writeLockFileMutex.Lock()
	ret, specificReturn := fake.writeLockFileReturnsOnCall[len(fake.writeLockFileArgsForCall)]
	fake.writeLockFileArgsForCall = append(fake.writeLockFileArgsForCall, struct {
		arg1 string
	}{arg1})
	stub := fake.WriteLockFileStub
	fakeReturns := fake.writeLockFileReturns
	fake.recordInvocation("WriteLockFile", []interface{}{arg1})
	fake.writeLockFileMutex.Unlock()
	if stub != nil {
		return stub(arg1)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeStorage) WriteLockFileCallCount() int {
	fake.writeLockFileMutex.RLock()
	defer fake.writeLockFileMutex.RUnlock()
	return len(fake.writeLockFileArgsForCall)
}

func (fake *FakeStorage) WriteLockFileCalls(stub func(string) error) {
	fake.writeLockFileMutex.Lock()
	defer fake.writeLockFileMutex.Unlock()
	fake.WriteLockFileStub = stub
}

func (fake *FakeStorage) WriteLockFileArgsForCall(i int) string {
	fake.writeLockFileMutex.RLock()
	defer fake.writeLockFileMutex.RUnlock()
	argsForCall := fake.writeLockFileArgsForCall[i]
	return argsForCall.arg1
}

func (fake *FakeStorage) WriteLockFileReturns(result1 error) {
	fake.writeLockFileMutex.Lock()
	defer fake.writeLockFileMutex.Unlock()
	fake.WriteLockFileStub = nil
	fake.writeLockFileReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) WriteLockFileReturnsOnCall(i int, result1 error) {
	fake.writeLockFileMutex.Lock()
	defer fake.writeLockFileMutex.Unlock()
	fake.WriteLockFileStub = nil
	if fake.writeLockFileReturnsOnCall == nil {
		fake.writeLockFileReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.writeLockFileReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeStorage) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createServiceBindingCredentialsMutex.RLock()
	defer fake.createServiceBindingCredentialsMutex.RUnlock()
	fake.deleteBindRequestDetailsMutex.RLock()
	defer fake.deleteBindRequestDetailsMutex.RUnlock()
	fake.deleteProvisionRequestDetailsMutex.RLock()
	defer fake.deleteProvisionRequestDetailsMutex.RUnlock()
	fake.deleteServiceBindingCredentialsMutex.RLock()
	defer fake.deleteServiceBindingCredentialsMutex.RUnlock()
	fake.deleteServiceInstanceDetailsMutex.RLock()
	defer fake.deleteServiceInstanceDetailsMutex.RUnlock()
	fake.deleteTerraformDeploymentMutex.RLock()
	defer fake.deleteTerraformDeploymentMutex.RUnlock()
	fake.existsServiceBindingCredentialsMutex.RLock()
	defer fake.existsServiceBindingCredentialsMutex.RUnlock()
	fake.existsServiceInstanceDetailsMutex.RLock()
	defer fake.existsServiceInstanceDetailsMutex.RUnlock()
	fake.existsTerraformDeploymentMutex.RLock()
	defer fake.existsTerraformDeploymentMutex.RUnlock()
	fake.getBindRequestDetailsMutex.RLock()
	defer fake.getBindRequestDetailsMutex.RUnlock()
	fake.getProvisionRequestDetailsMutex.RLock()
	defer fake.getProvisionRequestDetailsMutex.RUnlock()
	fake.getServiceBindingCredentialsMutex.RLock()
	defer fake.getServiceBindingCredentialsMutex.RUnlock()
	fake.getServiceBindingIDsForServiceInstanceMutex.RLock()
	defer fake.getServiceBindingIDsForServiceInstanceMutex.RUnlock()
	fake.getServiceInstanceDetailsMutex.RLock()
	defer fake.getServiceInstanceDetailsMutex.RUnlock()
	fake.getTerraformDeploymentMutex.RLock()
	defer fake.getTerraformDeploymentMutex.RUnlock()
	fake.removeLockFileMutex.RLock()
	defer fake.removeLockFileMutex.RUnlock()
	fake.storeBindRequestDetailsMutex.RLock()
	defer fake.storeBindRequestDetailsMutex.RUnlock()
	fake.storeProvisionRequestDetailsMutex.RLock()
	defer fake.storeProvisionRequestDetailsMutex.RUnlock()
	fake.storeServiceInstanceDetailsMutex.RLock()
	defer fake.storeServiceInstanceDetailsMutex.RUnlock()
	fake.storeTerraformDeploymentMutex.RLock()
	defer fake.storeTerraformDeploymentMutex.RUnlock()
	fake.writeLockFileMutex.RLock()
	defer fake.writeLockFileMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeStorage) 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 _ broker.Storage = new(FakeStorage)
