sdf

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

import (
	"context"
	"sync"
	"time"

	"github.com/certifaction/api/model"
	"github.com/certifaction/api/signature_requests/repository"
)

type FakeRepository struct {
	CreateStub        func(context.Context, *model.SignatureRequest) error
	createMutex       sync.RWMutex
	createArgsForCall []struct {
		arg1 context.Context
		arg2 *model.SignatureRequest
	}
	createReturns struct {
		result1 error
	}
	createReturnsOnCall map[int]struct {
		result1 error
	}
	CreateTokenStub        func(context.Context, string, *model.SignatureRequestsToken) error
	createTokenMutex       sync.RWMutex
	createTokenArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 *model.SignatureRequestsToken
	}
	createTokenReturns struct {
		result1 error
	}
	createTokenReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteAccessByFileIDStub        func(context.Context, string) error
	deleteAccessByFileIDMutex       sync.RWMutex
	deleteAccessByFileIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	deleteAccessByFileIDReturns struct {
		result1 error
	}
	deleteAccessByFileIDReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteByFileIDAndSignerUIDStub        func(context.Context, string, string, string) error
	deleteByFileIDAndSignerUIDMutex       sync.RWMutex
	deleteByFileIDAndSignerUIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 string
		arg4 string
	}
	deleteByFileIDAndSignerUIDReturns struct {
		result1 error
	}
	deleteByFileIDAndSignerUIDReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteByIDStub        func(context.Context, string) error
	deleteByIDMutex       sync.RWMutex
	deleteByIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	deleteByIDReturns struct {
		result1 error
	}
	deleteByIDReturnsOnCall map[int]struct {
		result1 error
	}
	DeleteTokensStub        func(context.Context, string) error
	deleteTokensMutex       sync.RWMutex
	deleteTokensArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	deleteTokensReturns struct {
		result1 error
	}
	deleteTokensReturnsOnCall map[int]struct {
		result1 error
	}
	FindActiveForOrganizationStub        func(context.Context, string) ([]model.SignatureRequest, error)
	findActiveForOrganizationMutex       sync.RWMutex
	findActiveForOrganizationArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findActiveForOrganizationReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findActiveForOrganizationReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindAllForOrganizationStub        func(context.Context, string) ([]model.SignatureRequest, error)
	findAllForOrganizationMutex       sync.RWMutex
	findAllForOrganizationArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findAllForOrganizationReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findAllForOrganizationReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindAllForSignerStub        func(context.Context, string) ([]model.SignatureRequest, error)
	findAllForSignerMutex       sync.RWMutex
	findAllForSignerArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findAllForSignerReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findAllForSignerReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindByDocumentIDAndSignerUIDStub        func(context.Context, string, string) (*model.SignatureRequest, error)
	findByDocumentIDAndSignerUIDMutex       sync.RWMutex
	findByDocumentIDAndSignerUIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}
	findByDocumentIDAndSignerUIDReturns struct {
		result1 *model.SignatureRequest
		result2 error
	}
	findByDocumentIDAndSignerUIDReturnsOnCall map[int]struct {
		result1 *model.SignatureRequest
		result2 error
	}
	FindByFileIDStub        func(context.Context, []string, bool) ([]model.SignatureRequest, error)
	findByFileIDMutex       sync.RWMutex
	findByFileIDArgsForCall []struct {
		arg1 context.Context
		arg2 []string
		arg3 bool
	}
	findByFileIDReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findByFileIDReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindByFileIDAndSignerUIDStub        func(context.Context, string, string) (*model.SignatureRequest, error)
	findByFileIDAndSignerUIDMutex       sync.RWMutex
	findByFileIDAndSignerUIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}
	findByFileIDAndSignerUIDReturns struct {
		result1 *model.SignatureRequest
		result2 error
	}
	findByFileIDAndSignerUIDReturnsOnCall map[int]struct {
		result1 *model.SignatureRequest
		result2 error
	}
	FindByFileIDsAndSignerStub        func(context.Context, []string, *model.User, bool, bool) ([]model.SignatureRequest, error)
	findByFileIDsAndSignerMutex       sync.RWMutex
	findByFileIDsAndSignerArgsForCall []struct {
		arg1 context.Context
		arg2 []string
		arg3 *model.User
		arg4 bool
		arg5 bool
	}
	findByFileIDsAndSignerReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findByFileIDsAndSignerReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindByHashedSignerTokenStub        func(context.Context, string) (*model.SignatureRequest, error)
	findByHashedSignerTokenMutex       sync.RWMutex
	findByHashedSignerTokenArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findByHashedSignerTokenReturns struct {
		result1 *model.SignatureRequest
		result2 error
	}
	findByHashedSignerTokenReturnsOnCall map[int]struct {
		result1 *model.SignatureRequest
		result2 error
	}
	FindByIDStub        func(context.Context, string) (*model.SignatureRequest, error)
	findByIDMutex       sync.RWMutex
	findByIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findByIDReturns struct {
		result1 *model.SignatureRequest
		result2 error
	}
	findByIDReturnsOnCall map[int]struct {
		result1 *model.SignatureRequest
		result2 error
	}
	FindByIDForSignerUIDStub        func(context.Context, string, string) (*model.SignatureRequest, error)
	findByIDForSignerUIDMutex       sync.RWMutex
	findByIDForSignerUIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}
	findByIDForSignerUIDReturns struct {
		result1 *model.SignatureRequest
		result2 error
	}
	findByIDForSignerUIDReturnsOnCall map[int]struct {
		result1 *model.SignatureRequest
		result2 error
	}
	FindByProcessIDStub        func(context.Context, string) ([]model.SignatureRequest, error)
	findByProcessIDMutex       sync.RWMutex
	findByProcessIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findByProcessIDReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findByProcessIDReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub        func(context.Context, string, time.Time, int) ([]model.SignatureRequest, error)
	findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex       sync.RWMutex
	findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 time.Time
		arg4 int
	}
	findByRequestorCreatedBeforeNotAnonymizedForUpdateReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindBySignerUIDStub        func(context.Context, string) (*model.SignatureRequest, error)
	findBySignerUIDMutex       sync.RWMutex
	findBySignerUIDArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findBySignerUIDReturns struct {
		result1 *model.SignatureRequest
		result2 error
	}
	findBySignerUIDReturnsOnCall map[int]struct {
		result1 *model.SignatureRequest
		result2 error
	}
	FindBySignerWithNameOrEmailLikeStub        func(context.Context, string, string) ([]model.SignatureRequest, error)
	findBySignerWithNameOrEmailLikeMutex       sync.RWMutex
	findBySignerWithNameOrEmailLikeArgsForCall []struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}
	findBySignerWithNameOrEmailLikeReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findBySignerWithNameOrEmailLikeReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindCompletedForOrganizationStub        func(context.Context, string) ([]model.SignatureRequest, error)
	findCompletedForOrganizationMutex       sync.RWMutex
	findCompletedForOrganizationArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findCompletedForOrganizationReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findCompletedForOrganizationReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindExpiredBeforeStub        func(context.Context, time.Time) ([]model.SignatureRequest, error)
	findExpiredBeforeMutex       sync.RWMutex
	findExpiredBeforeArgsForCall []struct {
		arg1 context.Context
		arg2 time.Time
	}
	findExpiredBeforeReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findExpiredBeforeReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindExpiredByFileIdStub        func(context.Context, string) ([]model.SignatureRequest, error)
	findExpiredByFileIdMutex       sync.RWMutex
	findExpiredByFileIdArgsForCall []struct {
		arg1 context.Context
		arg2 string
	}
	findExpiredByFileIdReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findExpiredByFileIdReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub        func(context.Context, time.Time, int) ([]model.SignatureRequest, error)
	findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex       sync.RWMutex
	findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall []struct {
		arg1 context.Context
		arg2 time.Time
		arg3 int
	}
	findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns struct {
		result1 []model.SignatureRequest
		result2 error
	}
	findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall map[int]struct {
		result1 []model.SignatureRequest
		result2 error
	}
	UpdateStub        func(context.Context, *model.SignatureRequest) error
	updateMutex       sync.RWMutex
	updateArgsForCall []struct {
		arg1 context.Context
		arg2 *model.SignatureRequest
	}
	updateReturns struct {
		result1 error
	}
	updateReturnsOnCall map[int]struct {
		result1 error
	}
	invocations      map[string][][]interface{}
	invocationsMutex sync.RWMutex
}

func (fake *FakeRepository) Create(arg1 context.Context, arg2 *model.SignatureRequest) error {
	fake.createMutex.Lock()
	ret, specificReturn := fake.createReturnsOnCall[len(fake.createArgsForCall)]
	fake.createArgsForCall = append(fake.createArgsForCall, struct {
		arg1 context.Context
		arg2 *model.SignatureRequest
	}{arg1, arg2})
	stub := fake.CreateStub
	fakeReturns := fake.createReturns
	fake.recordInvocation("Create", []interface{}{arg1, arg2})
	fake.createMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) CreateCallCount() int {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	return len(fake.createArgsForCall)
}

func (fake *FakeRepository) CreateCalls(stub func(context.Context, *model.SignatureRequest) error) {
	fake.createMutex.Lock()
	defer fake.createMutex.Unlock()
	fake.CreateStub = stub
}

func (fake *FakeRepository) CreateArgsForCall(i int) (context.Context, *model.SignatureRequest) {
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	argsForCall := fake.createArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) CreateReturns(result1 error) {
	fake.createMutex.Lock()
	defer fake.createMutex.Unlock()
	fake.CreateStub = nil
	fake.createReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) CreateReturnsOnCall(i int, result1 error) {
	fake.createMutex.Lock()
	defer fake.createMutex.Unlock()
	fake.CreateStub = nil
	if fake.createReturnsOnCall == nil {
		fake.createReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) CreateToken(arg1 context.Context, arg2 string, arg3 *model.SignatureRequestsToken) error {
	fake.createTokenMutex.Lock()
	ret, specificReturn := fake.createTokenReturnsOnCall[len(fake.createTokenArgsForCall)]
	fake.createTokenArgsForCall = append(fake.createTokenArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 *model.SignatureRequestsToken
	}{arg1, arg2, arg3})
	stub := fake.CreateTokenStub
	fakeReturns := fake.createTokenReturns
	fake.recordInvocation("CreateToken", []interface{}{arg1, arg2, arg3})
	fake.createTokenMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) CreateTokenCallCount() int {
	fake.createTokenMutex.RLock()
	defer fake.createTokenMutex.RUnlock()
	return len(fake.createTokenArgsForCall)
}

func (fake *FakeRepository) CreateTokenCalls(stub func(context.Context, string, *model.SignatureRequestsToken) error) {
	fake.createTokenMutex.Lock()
	defer fake.createTokenMutex.Unlock()
	fake.CreateTokenStub = stub
}

func (fake *FakeRepository) CreateTokenArgsForCall(i int) (context.Context, string, *model.SignatureRequestsToken) {
	fake.createTokenMutex.RLock()
	defer fake.createTokenMutex.RUnlock()
	argsForCall := fake.createTokenArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) CreateTokenReturns(result1 error) {
	fake.createTokenMutex.Lock()
	defer fake.createTokenMutex.Unlock()
	fake.CreateTokenStub = nil
	fake.createTokenReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) CreateTokenReturnsOnCall(i int, result1 error) {
	fake.createTokenMutex.Lock()
	defer fake.createTokenMutex.Unlock()
	fake.CreateTokenStub = nil
	if fake.createTokenReturnsOnCall == nil {
		fake.createTokenReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.createTokenReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteAccessByFileID(arg1 context.Context, arg2 string) error {
	fake.deleteAccessByFileIDMutex.Lock()
	ret, specificReturn := fake.deleteAccessByFileIDReturnsOnCall[len(fake.deleteAccessByFileIDArgsForCall)]
	fake.deleteAccessByFileIDArgsForCall = append(fake.deleteAccessByFileIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteAccessByFileIDStub
	fakeReturns := fake.deleteAccessByFileIDReturns
	fake.recordInvocation("DeleteAccessByFileID", []interface{}{arg1, arg2})
	fake.deleteAccessByFileIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) DeleteAccessByFileIDCallCount() int {
	fake.deleteAccessByFileIDMutex.RLock()
	defer fake.deleteAccessByFileIDMutex.RUnlock()
	return len(fake.deleteAccessByFileIDArgsForCall)
}

func (fake *FakeRepository) DeleteAccessByFileIDCalls(stub func(context.Context, string) error) {
	fake.deleteAccessByFileIDMutex.Lock()
	defer fake.deleteAccessByFileIDMutex.Unlock()
	fake.DeleteAccessByFileIDStub = stub
}

func (fake *FakeRepository) DeleteAccessByFileIDArgsForCall(i int) (context.Context, string) {
	fake.deleteAccessByFileIDMutex.RLock()
	defer fake.deleteAccessByFileIDMutex.RUnlock()
	argsForCall := fake.deleteAccessByFileIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) DeleteAccessByFileIDReturns(result1 error) {
	fake.deleteAccessByFileIDMutex.Lock()
	defer fake.deleteAccessByFileIDMutex.Unlock()
	fake.DeleteAccessByFileIDStub = nil
	fake.deleteAccessByFileIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteAccessByFileIDReturnsOnCall(i int, result1 error) {
	fake.deleteAccessByFileIDMutex.Lock()
	defer fake.deleteAccessByFileIDMutex.Unlock()
	fake.DeleteAccessByFileIDStub = nil
	if fake.deleteAccessByFileIDReturnsOnCall == nil {
		fake.deleteAccessByFileIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteAccessByFileIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteByFileIDAndSignerUID(arg1 context.Context, arg2 string, arg3 string, arg4 string) error {
	fake.deleteByFileIDAndSignerUIDMutex.Lock()
	ret, specificReturn := fake.deleteByFileIDAndSignerUIDReturnsOnCall[len(fake.deleteByFileIDAndSignerUIDArgsForCall)]
	fake.deleteByFileIDAndSignerUIDArgsForCall = append(fake.deleteByFileIDAndSignerUIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 string
		arg4 string
	}{arg1, arg2, arg3, arg4})
	stub := fake.DeleteByFileIDAndSignerUIDStub
	fakeReturns := fake.deleteByFileIDAndSignerUIDReturns
	fake.recordInvocation("DeleteByFileIDAndSignerUID", []interface{}{arg1, arg2, arg3, arg4})
	fake.deleteByFileIDAndSignerUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) DeleteByFileIDAndSignerUIDCallCount() int {
	fake.deleteByFileIDAndSignerUIDMutex.RLock()
	defer fake.deleteByFileIDAndSignerUIDMutex.RUnlock()
	return len(fake.deleteByFileIDAndSignerUIDArgsForCall)
}

func (fake *FakeRepository) DeleteByFileIDAndSignerUIDCalls(stub func(context.Context, string, string, string) error) {
	fake.deleteByFileIDAndSignerUIDMutex.Lock()
	defer fake.deleteByFileIDAndSignerUIDMutex.Unlock()
	fake.DeleteByFileIDAndSignerUIDStub = stub
}

func (fake *FakeRepository) DeleteByFileIDAndSignerUIDArgsForCall(i int) (context.Context, string, string, string) {
	fake.deleteByFileIDAndSignerUIDMutex.RLock()
	defer fake.deleteByFileIDAndSignerUIDMutex.RUnlock()
	argsForCall := fake.deleteByFileIDAndSignerUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeRepository) DeleteByFileIDAndSignerUIDReturns(result1 error) {
	fake.deleteByFileIDAndSignerUIDMutex.Lock()
	defer fake.deleteByFileIDAndSignerUIDMutex.Unlock()
	fake.DeleteByFileIDAndSignerUIDStub = nil
	fake.deleteByFileIDAndSignerUIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteByFileIDAndSignerUIDReturnsOnCall(i int, result1 error) {
	fake.deleteByFileIDAndSignerUIDMutex.Lock()
	defer fake.deleteByFileIDAndSignerUIDMutex.Unlock()
	fake.DeleteByFileIDAndSignerUIDStub = nil
	if fake.deleteByFileIDAndSignerUIDReturnsOnCall == nil {
		fake.deleteByFileIDAndSignerUIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteByFileIDAndSignerUIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteByID(arg1 context.Context, arg2 string) error {
	fake.deleteByIDMutex.Lock()
	ret, specificReturn := fake.deleteByIDReturnsOnCall[len(fake.deleteByIDArgsForCall)]
	fake.deleteByIDArgsForCall = append(fake.deleteByIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteByIDStub
	fakeReturns := fake.deleteByIDReturns
	fake.recordInvocation("DeleteByID", []interface{}{arg1, arg2})
	fake.deleteByIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) DeleteByIDCallCount() int {
	fake.deleteByIDMutex.RLock()
	defer fake.deleteByIDMutex.RUnlock()
	return len(fake.deleteByIDArgsForCall)
}

func (fake *FakeRepository) DeleteByIDCalls(stub func(context.Context, string) error) {
	fake.deleteByIDMutex.Lock()
	defer fake.deleteByIDMutex.Unlock()
	fake.DeleteByIDStub = stub
}

func (fake *FakeRepository) DeleteByIDArgsForCall(i int) (context.Context, string) {
	fake.deleteByIDMutex.RLock()
	defer fake.deleteByIDMutex.RUnlock()
	argsForCall := fake.deleteByIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) DeleteByIDReturns(result1 error) {
	fake.deleteByIDMutex.Lock()
	defer fake.deleteByIDMutex.Unlock()
	fake.DeleteByIDStub = nil
	fake.deleteByIDReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteByIDReturnsOnCall(i int, result1 error) {
	fake.deleteByIDMutex.Lock()
	defer fake.deleteByIDMutex.Unlock()
	fake.DeleteByIDStub = nil
	if fake.deleteByIDReturnsOnCall == nil {
		fake.deleteByIDReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteByIDReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteTokens(arg1 context.Context, arg2 string) error {
	fake.deleteTokensMutex.Lock()
	ret, specificReturn := fake.deleteTokensReturnsOnCall[len(fake.deleteTokensArgsForCall)]
	fake.deleteTokensArgsForCall = append(fake.deleteTokensArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.DeleteTokensStub
	fakeReturns := fake.deleteTokensReturns
	fake.recordInvocation("DeleteTokens", []interface{}{arg1, arg2})
	fake.deleteTokensMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) DeleteTokensCallCount() int {
	fake.deleteTokensMutex.RLock()
	defer fake.deleteTokensMutex.RUnlock()
	return len(fake.deleteTokensArgsForCall)
}

func (fake *FakeRepository) DeleteTokensCalls(stub func(context.Context, string) error) {
	fake.deleteTokensMutex.Lock()
	defer fake.deleteTokensMutex.Unlock()
	fake.DeleteTokensStub = stub
}

func (fake *FakeRepository) DeleteTokensArgsForCall(i int) (context.Context, string) {
	fake.deleteTokensMutex.RLock()
	defer fake.deleteTokensMutex.RUnlock()
	argsForCall := fake.deleteTokensArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) DeleteTokensReturns(result1 error) {
	fake.deleteTokensMutex.Lock()
	defer fake.deleteTokensMutex.Unlock()
	fake.DeleteTokensStub = nil
	fake.deleteTokensReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) DeleteTokensReturnsOnCall(i int, result1 error) {
	fake.deleteTokensMutex.Lock()
	defer fake.deleteTokensMutex.Unlock()
	fake.DeleteTokensStub = nil
	if fake.deleteTokensReturnsOnCall == nil {
		fake.deleteTokensReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.deleteTokensReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) FindActiveForOrganization(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) {
	fake.findActiveForOrganizationMutex.Lock()
	ret, specificReturn := fake.findActiveForOrganizationReturnsOnCall[len(fake.findActiveForOrganizationArgsForCall)]
	fake.findActiveForOrganizationArgsForCall = append(fake.findActiveForOrganizationArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindActiveForOrganizationStub
	fakeReturns := fake.findActiveForOrganizationReturns
	fake.recordInvocation("FindActiveForOrganization", []interface{}{arg1, arg2})
	fake.findActiveForOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindActiveForOrganizationCallCount() int {
	fake.findActiveForOrganizationMutex.RLock()
	defer fake.findActiveForOrganizationMutex.RUnlock()
	return len(fake.findActiveForOrganizationArgsForCall)
}

func (fake *FakeRepository) FindActiveForOrganizationCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) {
	fake.findActiveForOrganizationMutex.Lock()
	defer fake.findActiveForOrganizationMutex.Unlock()
	fake.FindActiveForOrganizationStub = stub
}

func (fake *FakeRepository) FindActiveForOrganizationArgsForCall(i int) (context.Context, string) {
	fake.findActiveForOrganizationMutex.RLock()
	defer fake.findActiveForOrganizationMutex.RUnlock()
	argsForCall := fake.findActiveForOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindActiveForOrganizationReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findActiveForOrganizationMutex.Lock()
	defer fake.findActiveForOrganizationMutex.Unlock()
	fake.FindActiveForOrganizationStub = nil
	fake.findActiveForOrganizationReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindActiveForOrganizationReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findActiveForOrganizationMutex.Lock()
	defer fake.findActiveForOrganizationMutex.Unlock()
	fake.FindActiveForOrganizationStub = nil
	if fake.findActiveForOrganizationReturnsOnCall == nil {
		fake.findActiveForOrganizationReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findActiveForOrganizationReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindAllForOrganization(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) {
	fake.findAllForOrganizationMutex.Lock()
	ret, specificReturn := fake.findAllForOrganizationReturnsOnCall[len(fake.findAllForOrganizationArgsForCall)]
	fake.findAllForOrganizationArgsForCall = append(fake.findAllForOrganizationArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindAllForOrganizationStub
	fakeReturns := fake.findAllForOrganizationReturns
	fake.recordInvocation("FindAllForOrganization", []interface{}{arg1, arg2})
	fake.findAllForOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindAllForOrganizationCallCount() int {
	fake.findAllForOrganizationMutex.RLock()
	defer fake.findAllForOrganizationMutex.RUnlock()
	return len(fake.findAllForOrganizationArgsForCall)
}

func (fake *FakeRepository) FindAllForOrganizationCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) {
	fake.findAllForOrganizationMutex.Lock()
	defer fake.findAllForOrganizationMutex.Unlock()
	fake.FindAllForOrganizationStub = stub
}

func (fake *FakeRepository) FindAllForOrganizationArgsForCall(i int) (context.Context, string) {
	fake.findAllForOrganizationMutex.RLock()
	defer fake.findAllForOrganizationMutex.RUnlock()
	argsForCall := fake.findAllForOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindAllForOrganizationReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findAllForOrganizationMutex.Lock()
	defer fake.findAllForOrganizationMutex.Unlock()
	fake.FindAllForOrganizationStub = nil
	fake.findAllForOrganizationReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindAllForOrganizationReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findAllForOrganizationMutex.Lock()
	defer fake.findAllForOrganizationMutex.Unlock()
	fake.FindAllForOrganizationStub = nil
	if fake.findAllForOrganizationReturnsOnCall == nil {
		fake.findAllForOrganizationReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findAllForOrganizationReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindAllForSigner(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) {
	fake.findAllForSignerMutex.Lock()
	ret, specificReturn := fake.findAllForSignerReturnsOnCall[len(fake.findAllForSignerArgsForCall)]
	fake.findAllForSignerArgsForCall = append(fake.findAllForSignerArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindAllForSignerStub
	fakeReturns := fake.findAllForSignerReturns
	fake.recordInvocation("FindAllForSigner", []interface{}{arg1, arg2})
	fake.findAllForSignerMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindAllForSignerCallCount() int {
	fake.findAllForSignerMutex.RLock()
	defer fake.findAllForSignerMutex.RUnlock()
	return len(fake.findAllForSignerArgsForCall)
}

func (fake *FakeRepository) FindAllForSignerCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) {
	fake.findAllForSignerMutex.Lock()
	defer fake.findAllForSignerMutex.Unlock()
	fake.FindAllForSignerStub = stub
}

func (fake *FakeRepository) FindAllForSignerArgsForCall(i int) (context.Context, string) {
	fake.findAllForSignerMutex.RLock()
	defer fake.findAllForSignerMutex.RUnlock()
	argsForCall := fake.findAllForSignerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindAllForSignerReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findAllForSignerMutex.Lock()
	defer fake.findAllForSignerMutex.Unlock()
	fake.FindAllForSignerStub = nil
	fake.findAllForSignerReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindAllForSignerReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findAllForSignerMutex.Lock()
	defer fake.findAllForSignerMutex.Unlock()
	fake.FindAllForSignerStub = nil
	if fake.findAllForSignerReturnsOnCall == nil {
		fake.findAllForSignerReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findAllForSignerReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByDocumentIDAndSignerUID(arg1 context.Context, arg2 string, arg3 string) (*model.SignatureRequest, error) {
	fake.findByDocumentIDAndSignerUIDMutex.Lock()
	ret, specificReturn := fake.findByDocumentIDAndSignerUIDReturnsOnCall[len(fake.findByDocumentIDAndSignerUIDArgsForCall)]
	fake.findByDocumentIDAndSignerUIDArgsForCall = append(fake.findByDocumentIDAndSignerUIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.FindByDocumentIDAndSignerUIDStub
	fakeReturns := fake.findByDocumentIDAndSignerUIDReturns
	fake.recordInvocation("FindByDocumentIDAndSignerUID", []interface{}{arg1, arg2, arg3})
	fake.findByDocumentIDAndSignerUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByDocumentIDAndSignerUIDCallCount() int {
	fake.findByDocumentIDAndSignerUIDMutex.RLock()
	defer fake.findByDocumentIDAndSignerUIDMutex.RUnlock()
	return len(fake.findByDocumentIDAndSignerUIDArgsForCall)
}

func (fake *FakeRepository) FindByDocumentIDAndSignerUIDCalls(stub func(context.Context, string, string) (*model.SignatureRequest, error)) {
	fake.findByDocumentIDAndSignerUIDMutex.Lock()
	defer fake.findByDocumentIDAndSignerUIDMutex.Unlock()
	fake.FindByDocumentIDAndSignerUIDStub = stub
}

func (fake *FakeRepository) FindByDocumentIDAndSignerUIDArgsForCall(i int) (context.Context, string, string) {
	fake.findByDocumentIDAndSignerUIDMutex.RLock()
	defer fake.findByDocumentIDAndSignerUIDMutex.RUnlock()
	argsForCall := fake.findByDocumentIDAndSignerUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) FindByDocumentIDAndSignerUIDReturns(result1 *model.SignatureRequest, result2 error) {
	fake.findByDocumentIDAndSignerUIDMutex.Lock()
	defer fake.findByDocumentIDAndSignerUIDMutex.Unlock()
	fake.FindByDocumentIDAndSignerUIDStub = nil
	fake.findByDocumentIDAndSignerUIDReturns = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByDocumentIDAndSignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) {
	fake.findByDocumentIDAndSignerUIDMutex.Lock()
	defer fake.findByDocumentIDAndSignerUIDMutex.Unlock()
	fake.FindByDocumentIDAndSignerUIDStub = nil
	if fake.findByDocumentIDAndSignerUIDReturnsOnCall == nil {
		fake.findByDocumentIDAndSignerUIDReturnsOnCall = make(map[int]struct {
			result1 *model.SignatureRequest
			result2 error
		})
	}
	fake.findByDocumentIDAndSignerUIDReturnsOnCall[i] = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByFileID(arg1 context.Context, arg2 []string, arg3 bool) ([]model.SignatureRequest, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.findByFileIDMutex.Lock()
	ret, specificReturn := fake.findByFileIDReturnsOnCall[len(fake.findByFileIDArgsForCall)]
	fake.findByFileIDArgsForCall = append(fake.findByFileIDArgsForCall, struct {
		arg1 context.Context
		arg2 []string
		arg3 bool
	}{arg1, arg2Copy, arg3})
	stub := fake.FindByFileIDStub
	fakeReturns := fake.findByFileIDReturns
	fake.recordInvocation("FindByFileID", []interface{}{arg1, arg2Copy, arg3})
	fake.findByFileIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByFileIDCallCount() int {
	fake.findByFileIDMutex.RLock()
	defer fake.findByFileIDMutex.RUnlock()
	return len(fake.findByFileIDArgsForCall)
}

func (fake *FakeRepository) FindByFileIDCalls(stub func(context.Context, []string, bool) ([]model.SignatureRequest, error)) {
	fake.findByFileIDMutex.Lock()
	defer fake.findByFileIDMutex.Unlock()
	fake.FindByFileIDStub = stub
}

func (fake *FakeRepository) FindByFileIDArgsForCall(i int) (context.Context, []string, bool) {
	fake.findByFileIDMutex.RLock()
	defer fake.findByFileIDMutex.RUnlock()
	argsForCall := fake.findByFileIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) FindByFileIDReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findByFileIDMutex.Lock()
	defer fake.findByFileIDMutex.Unlock()
	fake.FindByFileIDStub = nil
	fake.findByFileIDReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByFileIDReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findByFileIDMutex.Lock()
	defer fake.findByFileIDMutex.Unlock()
	fake.FindByFileIDStub = nil
	if fake.findByFileIDReturnsOnCall == nil {
		fake.findByFileIDReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findByFileIDReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByFileIDAndSignerUID(arg1 context.Context, arg2 string, arg3 string) (*model.SignatureRequest, error) {
	fake.findByFileIDAndSignerUIDMutex.Lock()
	ret, specificReturn := fake.findByFileIDAndSignerUIDReturnsOnCall[len(fake.findByFileIDAndSignerUIDArgsForCall)]
	fake.findByFileIDAndSignerUIDArgsForCall = append(fake.findByFileIDAndSignerUIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.FindByFileIDAndSignerUIDStub
	fakeReturns := fake.findByFileIDAndSignerUIDReturns
	fake.recordInvocation("FindByFileIDAndSignerUID", []interface{}{arg1, arg2, arg3})
	fake.findByFileIDAndSignerUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByFileIDAndSignerUIDCallCount() int {
	fake.findByFileIDAndSignerUIDMutex.RLock()
	defer fake.findByFileIDAndSignerUIDMutex.RUnlock()
	return len(fake.findByFileIDAndSignerUIDArgsForCall)
}

func (fake *FakeRepository) FindByFileIDAndSignerUIDCalls(stub func(context.Context, string, string) (*model.SignatureRequest, error)) {
	fake.findByFileIDAndSignerUIDMutex.Lock()
	defer fake.findByFileIDAndSignerUIDMutex.Unlock()
	fake.FindByFileIDAndSignerUIDStub = stub
}

func (fake *FakeRepository) FindByFileIDAndSignerUIDArgsForCall(i int) (context.Context, string, string) {
	fake.findByFileIDAndSignerUIDMutex.RLock()
	defer fake.findByFileIDAndSignerUIDMutex.RUnlock()
	argsForCall := fake.findByFileIDAndSignerUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) FindByFileIDAndSignerUIDReturns(result1 *model.SignatureRequest, result2 error) {
	fake.findByFileIDAndSignerUIDMutex.Lock()
	defer fake.findByFileIDAndSignerUIDMutex.Unlock()
	fake.FindByFileIDAndSignerUIDStub = nil
	fake.findByFileIDAndSignerUIDReturns = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByFileIDAndSignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) {
	fake.findByFileIDAndSignerUIDMutex.Lock()
	defer fake.findByFileIDAndSignerUIDMutex.Unlock()
	fake.FindByFileIDAndSignerUIDStub = nil
	if fake.findByFileIDAndSignerUIDReturnsOnCall == nil {
		fake.findByFileIDAndSignerUIDReturnsOnCall = make(map[int]struct {
			result1 *model.SignatureRequest
			result2 error
		})
	}
	fake.findByFileIDAndSignerUIDReturnsOnCall[i] = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByFileIDsAndSigner(arg1 context.Context, arg2 []string, arg3 *model.User, arg4 bool, arg5 bool) ([]model.SignatureRequest, error) {
	var arg2Copy []string
	if arg2 != nil {
		arg2Copy = make([]string, len(arg2))
		copy(arg2Copy, arg2)
	}
	fake.findByFileIDsAndSignerMutex.Lock()
	ret, specificReturn := fake.findByFileIDsAndSignerReturnsOnCall[len(fake.findByFileIDsAndSignerArgsForCall)]
	fake.findByFileIDsAndSignerArgsForCall = append(fake.findByFileIDsAndSignerArgsForCall, struct {
		arg1 context.Context
		arg2 []string
		arg3 *model.User
		arg4 bool
		arg5 bool
	}{arg1, arg2Copy, arg3, arg4, arg5})
	stub := fake.FindByFileIDsAndSignerStub
	fakeReturns := fake.findByFileIDsAndSignerReturns
	fake.recordInvocation("FindByFileIDsAndSigner", []interface{}{arg1, arg2Copy, arg3, arg4, arg5})
	fake.findByFileIDsAndSignerMutex.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 *FakeRepository) FindByFileIDsAndSignerCallCount() int {
	fake.findByFileIDsAndSignerMutex.RLock()
	defer fake.findByFileIDsAndSignerMutex.RUnlock()
	return len(fake.findByFileIDsAndSignerArgsForCall)
}

func (fake *FakeRepository) FindByFileIDsAndSignerCalls(stub func(context.Context, []string, *model.User, bool, bool) ([]model.SignatureRequest, error)) {
	fake.findByFileIDsAndSignerMutex.Lock()
	defer fake.findByFileIDsAndSignerMutex.Unlock()
	fake.FindByFileIDsAndSignerStub = stub
}

func (fake *FakeRepository) FindByFileIDsAndSignerArgsForCall(i int) (context.Context, []string, *model.User, bool, bool) {
	fake.findByFileIDsAndSignerMutex.RLock()
	defer fake.findByFileIDsAndSignerMutex.RUnlock()
	argsForCall := fake.findByFileIDsAndSignerArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
}

func (fake *FakeRepository) FindByFileIDsAndSignerReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findByFileIDsAndSignerMutex.Lock()
	defer fake.findByFileIDsAndSignerMutex.Unlock()
	fake.FindByFileIDsAndSignerStub = nil
	fake.findByFileIDsAndSignerReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByFileIDsAndSignerReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findByFileIDsAndSignerMutex.Lock()
	defer fake.findByFileIDsAndSignerMutex.Unlock()
	fake.FindByFileIDsAndSignerStub = nil
	if fake.findByFileIDsAndSignerReturnsOnCall == nil {
		fake.findByFileIDsAndSignerReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findByFileIDsAndSignerReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByHashedSignerToken(arg1 context.Context, arg2 string) (*model.SignatureRequest, error) {
	fake.findByHashedSignerTokenMutex.Lock()
	ret, specificReturn := fake.findByHashedSignerTokenReturnsOnCall[len(fake.findByHashedSignerTokenArgsForCall)]
	fake.findByHashedSignerTokenArgsForCall = append(fake.findByHashedSignerTokenArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindByHashedSignerTokenStub
	fakeReturns := fake.findByHashedSignerTokenReturns
	fake.recordInvocation("FindByHashedSignerToken", []interface{}{arg1, arg2})
	fake.findByHashedSignerTokenMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByHashedSignerTokenCallCount() int {
	fake.findByHashedSignerTokenMutex.RLock()
	defer fake.findByHashedSignerTokenMutex.RUnlock()
	return len(fake.findByHashedSignerTokenArgsForCall)
}

func (fake *FakeRepository) FindByHashedSignerTokenCalls(stub func(context.Context, string) (*model.SignatureRequest, error)) {
	fake.findByHashedSignerTokenMutex.Lock()
	defer fake.findByHashedSignerTokenMutex.Unlock()
	fake.FindByHashedSignerTokenStub = stub
}

func (fake *FakeRepository) FindByHashedSignerTokenArgsForCall(i int) (context.Context, string) {
	fake.findByHashedSignerTokenMutex.RLock()
	defer fake.findByHashedSignerTokenMutex.RUnlock()
	argsForCall := fake.findByHashedSignerTokenArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindByHashedSignerTokenReturns(result1 *model.SignatureRequest, result2 error) {
	fake.findByHashedSignerTokenMutex.Lock()
	defer fake.findByHashedSignerTokenMutex.Unlock()
	fake.FindByHashedSignerTokenStub = nil
	fake.findByHashedSignerTokenReturns = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByHashedSignerTokenReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) {
	fake.findByHashedSignerTokenMutex.Lock()
	defer fake.findByHashedSignerTokenMutex.Unlock()
	fake.FindByHashedSignerTokenStub = nil
	if fake.findByHashedSignerTokenReturnsOnCall == nil {
		fake.findByHashedSignerTokenReturnsOnCall = make(map[int]struct {
			result1 *model.SignatureRequest
			result2 error
		})
	}
	fake.findByHashedSignerTokenReturnsOnCall[i] = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByID(arg1 context.Context, arg2 string) (*model.SignatureRequest, error) {
	fake.findByIDMutex.Lock()
	ret, specificReturn := fake.findByIDReturnsOnCall[len(fake.findByIDArgsForCall)]
	fake.findByIDArgsForCall = append(fake.findByIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindByIDStub
	fakeReturns := fake.findByIDReturns
	fake.recordInvocation("FindByID", []interface{}{arg1, arg2})
	fake.findByIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByIDCallCount() int {
	fake.findByIDMutex.RLock()
	defer fake.findByIDMutex.RUnlock()
	return len(fake.findByIDArgsForCall)
}

func (fake *FakeRepository) FindByIDCalls(stub func(context.Context, string) (*model.SignatureRequest, error)) {
	fake.findByIDMutex.Lock()
	defer fake.findByIDMutex.Unlock()
	fake.FindByIDStub = stub
}

func (fake *FakeRepository) FindByIDArgsForCall(i int) (context.Context, string) {
	fake.findByIDMutex.RLock()
	defer fake.findByIDMutex.RUnlock()
	argsForCall := fake.findByIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindByIDReturns(result1 *model.SignatureRequest, result2 error) {
	fake.findByIDMutex.Lock()
	defer fake.findByIDMutex.Unlock()
	fake.FindByIDStub = nil
	fake.findByIDReturns = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) {
	fake.findByIDMutex.Lock()
	defer fake.findByIDMutex.Unlock()
	fake.FindByIDStub = nil
	if fake.findByIDReturnsOnCall == nil {
		fake.findByIDReturnsOnCall = make(map[int]struct {
			result1 *model.SignatureRequest
			result2 error
		})
	}
	fake.findByIDReturnsOnCall[i] = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByIDForSignerUID(arg1 context.Context, arg2 string, arg3 string) (*model.SignatureRequest, error) {
	fake.findByIDForSignerUIDMutex.Lock()
	ret, specificReturn := fake.findByIDForSignerUIDReturnsOnCall[len(fake.findByIDForSignerUIDArgsForCall)]
	fake.findByIDForSignerUIDArgsForCall = append(fake.findByIDForSignerUIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.FindByIDForSignerUIDStub
	fakeReturns := fake.findByIDForSignerUIDReturns
	fake.recordInvocation("FindByIDForSignerUID", []interface{}{arg1, arg2, arg3})
	fake.findByIDForSignerUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByIDForSignerUIDCallCount() int {
	fake.findByIDForSignerUIDMutex.RLock()
	defer fake.findByIDForSignerUIDMutex.RUnlock()
	return len(fake.findByIDForSignerUIDArgsForCall)
}

func (fake *FakeRepository) FindByIDForSignerUIDCalls(stub func(context.Context, string, string) (*model.SignatureRequest, error)) {
	fake.findByIDForSignerUIDMutex.Lock()
	defer fake.findByIDForSignerUIDMutex.Unlock()
	fake.FindByIDForSignerUIDStub = stub
}

func (fake *FakeRepository) FindByIDForSignerUIDArgsForCall(i int) (context.Context, string, string) {
	fake.findByIDForSignerUIDMutex.RLock()
	defer fake.findByIDForSignerUIDMutex.RUnlock()
	argsForCall := fake.findByIDForSignerUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) FindByIDForSignerUIDReturns(result1 *model.SignatureRequest, result2 error) {
	fake.findByIDForSignerUIDMutex.Lock()
	defer fake.findByIDForSignerUIDMutex.Unlock()
	fake.FindByIDForSignerUIDStub = nil
	fake.findByIDForSignerUIDReturns = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByIDForSignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) {
	fake.findByIDForSignerUIDMutex.Lock()
	defer fake.findByIDForSignerUIDMutex.Unlock()
	fake.FindByIDForSignerUIDStub = nil
	if fake.findByIDForSignerUIDReturnsOnCall == nil {
		fake.findByIDForSignerUIDReturnsOnCall = make(map[int]struct {
			result1 *model.SignatureRequest
			result2 error
		})
	}
	fake.findByIDForSignerUIDReturnsOnCall[i] = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByProcessID(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) {
	fake.findByProcessIDMutex.Lock()
	ret, specificReturn := fake.findByProcessIDReturnsOnCall[len(fake.findByProcessIDArgsForCall)]
	fake.findByProcessIDArgsForCall = append(fake.findByProcessIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindByProcessIDStub
	fakeReturns := fake.findByProcessIDReturns
	fake.recordInvocation("FindByProcessID", []interface{}{arg1, arg2})
	fake.findByProcessIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByProcessIDCallCount() int {
	fake.findByProcessIDMutex.RLock()
	defer fake.findByProcessIDMutex.RUnlock()
	return len(fake.findByProcessIDArgsForCall)
}

func (fake *FakeRepository) FindByProcessIDCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) {
	fake.findByProcessIDMutex.Lock()
	defer fake.findByProcessIDMutex.Unlock()
	fake.FindByProcessIDStub = stub
}

func (fake *FakeRepository) FindByProcessIDArgsForCall(i int) (context.Context, string) {
	fake.findByProcessIDMutex.RLock()
	defer fake.findByProcessIDMutex.RUnlock()
	argsForCall := fake.findByProcessIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindByProcessIDReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findByProcessIDMutex.Lock()
	defer fake.findByProcessIDMutex.Unlock()
	fake.FindByProcessIDStub = nil
	fake.findByProcessIDReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByProcessIDReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findByProcessIDMutex.Lock()
	defer fake.findByProcessIDMutex.Unlock()
	fake.FindByProcessIDStub = nil
	if fake.findByProcessIDReturnsOnCall == nil {
		fake.findByProcessIDReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findByProcessIDReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdate(arg1 context.Context, arg2 string, arg3 time.Time, arg4 int) ([]model.SignatureRequest, error) {
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock()
	ret, specificReturn := fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall[len(fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall)]
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall = append(fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 time.Time
		arg4 int
	}{arg1, arg2, arg3, arg4})
	stub := fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub
	fakeReturns := fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturns
	fake.recordInvocation("FindByRequestorCreatedBeforeNotAnonymizedForUpdate", []interface{}{arg1, arg2, arg3, arg4})
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3, arg4)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateCallCount() int {
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RLock()
	defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RUnlock()
	return len(fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall)
}

func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateCalls(stub func(context.Context, string, time.Time, int) ([]model.SignatureRequest, error)) {
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock()
	defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock()
	fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub = stub
}

func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall(i int) (context.Context, string, time.Time, int) {
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RLock()
	defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RUnlock()
	argsForCall := fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
}

func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock()
	defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock()
	fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub = nil
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Lock()
	defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.Unlock()
	fake.FindByRequestorCreatedBeforeNotAnonymizedForUpdateStub = nil
	if fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall == nil {
		fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindBySignerUID(arg1 context.Context, arg2 string) (*model.SignatureRequest, error) {
	fake.findBySignerUIDMutex.Lock()
	ret, specificReturn := fake.findBySignerUIDReturnsOnCall[len(fake.findBySignerUIDArgsForCall)]
	fake.findBySignerUIDArgsForCall = append(fake.findBySignerUIDArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindBySignerUIDStub
	fakeReturns := fake.findBySignerUIDReturns
	fake.recordInvocation("FindBySignerUID", []interface{}{arg1, arg2})
	fake.findBySignerUIDMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindBySignerUIDCallCount() int {
	fake.findBySignerUIDMutex.RLock()
	defer fake.findBySignerUIDMutex.RUnlock()
	return len(fake.findBySignerUIDArgsForCall)
}

func (fake *FakeRepository) FindBySignerUIDCalls(stub func(context.Context, string) (*model.SignatureRequest, error)) {
	fake.findBySignerUIDMutex.Lock()
	defer fake.findBySignerUIDMutex.Unlock()
	fake.FindBySignerUIDStub = stub
}

func (fake *FakeRepository) FindBySignerUIDArgsForCall(i int) (context.Context, string) {
	fake.findBySignerUIDMutex.RLock()
	defer fake.findBySignerUIDMutex.RUnlock()
	argsForCall := fake.findBySignerUIDArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindBySignerUIDReturns(result1 *model.SignatureRequest, result2 error) {
	fake.findBySignerUIDMutex.Lock()
	defer fake.findBySignerUIDMutex.Unlock()
	fake.FindBySignerUIDStub = nil
	fake.findBySignerUIDReturns = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindBySignerUIDReturnsOnCall(i int, result1 *model.SignatureRequest, result2 error) {
	fake.findBySignerUIDMutex.Lock()
	defer fake.findBySignerUIDMutex.Unlock()
	fake.FindBySignerUIDStub = nil
	if fake.findBySignerUIDReturnsOnCall == nil {
		fake.findBySignerUIDReturnsOnCall = make(map[int]struct {
			result1 *model.SignatureRequest
			result2 error
		})
	}
	fake.findBySignerUIDReturnsOnCall[i] = struct {
		result1 *model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindBySignerWithNameOrEmailLike(arg1 context.Context, arg2 string, arg3 string) ([]model.SignatureRequest, error) {
	fake.findBySignerWithNameOrEmailLikeMutex.Lock()
	ret, specificReturn := fake.findBySignerWithNameOrEmailLikeReturnsOnCall[len(fake.findBySignerWithNameOrEmailLikeArgsForCall)]
	fake.findBySignerWithNameOrEmailLikeArgsForCall = append(fake.findBySignerWithNameOrEmailLikeArgsForCall, struct {
		arg1 context.Context
		arg2 string
		arg3 string
	}{arg1, arg2, arg3})
	stub := fake.FindBySignerWithNameOrEmailLikeStub
	fakeReturns := fake.findBySignerWithNameOrEmailLikeReturns
	fake.recordInvocation("FindBySignerWithNameOrEmailLike", []interface{}{arg1, arg2, arg3})
	fake.findBySignerWithNameOrEmailLikeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeCallCount() int {
	fake.findBySignerWithNameOrEmailLikeMutex.RLock()
	defer fake.findBySignerWithNameOrEmailLikeMutex.RUnlock()
	return len(fake.findBySignerWithNameOrEmailLikeArgsForCall)
}

func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeCalls(stub func(context.Context, string, string) ([]model.SignatureRequest, error)) {
	fake.findBySignerWithNameOrEmailLikeMutex.Lock()
	defer fake.findBySignerWithNameOrEmailLikeMutex.Unlock()
	fake.FindBySignerWithNameOrEmailLikeStub = stub
}

func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeArgsForCall(i int) (context.Context, string, string) {
	fake.findBySignerWithNameOrEmailLikeMutex.RLock()
	defer fake.findBySignerWithNameOrEmailLikeMutex.RUnlock()
	argsForCall := fake.findBySignerWithNameOrEmailLikeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findBySignerWithNameOrEmailLikeMutex.Lock()
	defer fake.findBySignerWithNameOrEmailLikeMutex.Unlock()
	fake.FindBySignerWithNameOrEmailLikeStub = nil
	fake.findBySignerWithNameOrEmailLikeReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindBySignerWithNameOrEmailLikeReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findBySignerWithNameOrEmailLikeMutex.Lock()
	defer fake.findBySignerWithNameOrEmailLikeMutex.Unlock()
	fake.FindBySignerWithNameOrEmailLikeStub = nil
	if fake.findBySignerWithNameOrEmailLikeReturnsOnCall == nil {
		fake.findBySignerWithNameOrEmailLikeReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findBySignerWithNameOrEmailLikeReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindCompletedForOrganization(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) {
	fake.findCompletedForOrganizationMutex.Lock()
	ret, specificReturn := fake.findCompletedForOrganizationReturnsOnCall[len(fake.findCompletedForOrganizationArgsForCall)]
	fake.findCompletedForOrganizationArgsForCall = append(fake.findCompletedForOrganizationArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindCompletedForOrganizationStub
	fakeReturns := fake.findCompletedForOrganizationReturns
	fake.recordInvocation("FindCompletedForOrganization", []interface{}{arg1, arg2})
	fake.findCompletedForOrganizationMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindCompletedForOrganizationCallCount() int {
	fake.findCompletedForOrganizationMutex.RLock()
	defer fake.findCompletedForOrganizationMutex.RUnlock()
	return len(fake.findCompletedForOrganizationArgsForCall)
}

func (fake *FakeRepository) FindCompletedForOrganizationCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) {
	fake.findCompletedForOrganizationMutex.Lock()
	defer fake.findCompletedForOrganizationMutex.Unlock()
	fake.FindCompletedForOrganizationStub = stub
}

func (fake *FakeRepository) FindCompletedForOrganizationArgsForCall(i int) (context.Context, string) {
	fake.findCompletedForOrganizationMutex.RLock()
	defer fake.findCompletedForOrganizationMutex.RUnlock()
	argsForCall := fake.findCompletedForOrganizationArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindCompletedForOrganizationReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findCompletedForOrganizationMutex.Lock()
	defer fake.findCompletedForOrganizationMutex.Unlock()
	fake.FindCompletedForOrganizationStub = nil
	fake.findCompletedForOrganizationReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindCompletedForOrganizationReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findCompletedForOrganizationMutex.Lock()
	defer fake.findCompletedForOrganizationMutex.Unlock()
	fake.FindCompletedForOrganizationStub = nil
	if fake.findCompletedForOrganizationReturnsOnCall == nil {
		fake.findCompletedForOrganizationReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findCompletedForOrganizationReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindExpiredBefore(arg1 context.Context, arg2 time.Time) ([]model.SignatureRequest, error) {
	fake.findExpiredBeforeMutex.Lock()
	ret, specificReturn := fake.findExpiredBeforeReturnsOnCall[len(fake.findExpiredBeforeArgsForCall)]
	fake.findExpiredBeforeArgsForCall = append(fake.findExpiredBeforeArgsForCall, struct {
		arg1 context.Context
		arg2 time.Time
	}{arg1, arg2})
	stub := fake.FindExpiredBeforeStub
	fakeReturns := fake.findExpiredBeforeReturns
	fake.recordInvocation("FindExpiredBefore", []interface{}{arg1, arg2})
	fake.findExpiredBeforeMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindExpiredBeforeCallCount() int {
	fake.findExpiredBeforeMutex.RLock()
	defer fake.findExpiredBeforeMutex.RUnlock()
	return len(fake.findExpiredBeforeArgsForCall)
}

func (fake *FakeRepository) FindExpiredBeforeCalls(stub func(context.Context, time.Time) ([]model.SignatureRequest, error)) {
	fake.findExpiredBeforeMutex.Lock()
	defer fake.findExpiredBeforeMutex.Unlock()
	fake.FindExpiredBeforeStub = stub
}

func (fake *FakeRepository) FindExpiredBeforeArgsForCall(i int) (context.Context, time.Time) {
	fake.findExpiredBeforeMutex.RLock()
	defer fake.findExpiredBeforeMutex.RUnlock()
	argsForCall := fake.findExpiredBeforeArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindExpiredBeforeReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findExpiredBeforeMutex.Lock()
	defer fake.findExpiredBeforeMutex.Unlock()
	fake.FindExpiredBeforeStub = nil
	fake.findExpiredBeforeReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindExpiredBeforeReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findExpiredBeforeMutex.Lock()
	defer fake.findExpiredBeforeMutex.Unlock()
	fake.FindExpiredBeforeStub = nil
	if fake.findExpiredBeforeReturnsOnCall == nil {
		fake.findExpiredBeforeReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findExpiredBeforeReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindExpiredByFileId(arg1 context.Context, arg2 string) ([]model.SignatureRequest, error) {
	fake.findExpiredByFileIdMutex.Lock()
	ret, specificReturn := fake.findExpiredByFileIdReturnsOnCall[len(fake.findExpiredByFileIdArgsForCall)]
	fake.findExpiredByFileIdArgsForCall = append(fake.findExpiredByFileIdArgsForCall, struct {
		arg1 context.Context
		arg2 string
	}{arg1, arg2})
	stub := fake.FindExpiredByFileIdStub
	fakeReturns := fake.findExpiredByFileIdReturns
	fake.recordInvocation("FindExpiredByFileId", []interface{}{arg1, arg2})
	fake.findExpiredByFileIdMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindExpiredByFileIdCallCount() int {
	fake.findExpiredByFileIdMutex.RLock()
	defer fake.findExpiredByFileIdMutex.RUnlock()
	return len(fake.findExpiredByFileIdArgsForCall)
}

func (fake *FakeRepository) FindExpiredByFileIdCalls(stub func(context.Context, string) ([]model.SignatureRequest, error)) {
	fake.findExpiredByFileIdMutex.Lock()
	defer fake.findExpiredByFileIdMutex.Unlock()
	fake.FindExpiredByFileIdStub = stub
}

func (fake *FakeRepository) FindExpiredByFileIdArgsForCall(i int) (context.Context, string) {
	fake.findExpiredByFileIdMutex.RLock()
	defer fake.findExpiredByFileIdMutex.RUnlock()
	argsForCall := fake.findExpiredByFileIdArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) FindExpiredByFileIdReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findExpiredByFileIdMutex.Lock()
	defer fake.findExpiredByFileIdMutex.Unlock()
	fake.FindExpiredByFileIdStub = nil
	fake.findExpiredByFileIdReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindExpiredByFileIdReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findExpiredByFileIdMutex.Lock()
	defer fake.findExpiredByFileIdMutex.Unlock()
	fake.FindExpiredByFileIdStub = nil
	if fake.findExpiredByFileIdReturnsOnCall == nil {
		fake.findExpiredByFileIdReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findExpiredByFileIdReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelled(arg1 context.Context, arg2 time.Time, arg3 int) ([]model.SignatureRequest, error) {
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock()
	ret, specificReturn := fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall[len(fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall)]
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall = append(fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall, struct {
		arg1 context.Context
		arg2 time.Time
		arg3 int
	}{arg1, arg2, arg3})
	stub := fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub
	fakeReturns := fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns
	fake.recordInvocation("FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelled", []interface{}{arg1, arg2, arg3})
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2, arg3)
	}
	if specificReturn {
		return ret.result1, ret.result2
	}
	return fakeReturns.result1, fakeReturns.result2
}

func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledCallCount() int {
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RLock()
	defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RUnlock()
	return len(fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall)
}

func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledCalls(stub func(context.Context, time.Time, int) ([]model.SignatureRequest, error)) {
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock()
	defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock()
	fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub = stub
}

func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall(i int) (context.Context, time.Time, int) {
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RLock()
	defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RUnlock()
	argsForCall := fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
}

func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns(result1 []model.SignatureRequest, result2 error) {
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock()
	defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock()
	fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub = nil
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturns = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall(i int, result1 []model.SignatureRequest, result2 error) {
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Lock()
	defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.Unlock()
	fake.FindUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledStub = nil
	if fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall == nil {
		fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall = make(map[int]struct {
			result1 []model.SignatureRequest
			result2 error
		})
	}
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledReturnsOnCall[i] = struct {
		result1 []model.SignatureRequest
		result2 error
	}{result1, result2}
}

func (fake *FakeRepository) Update(arg1 context.Context, arg2 *model.SignatureRequest) error {
	fake.updateMutex.Lock()
	ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)]
	fake.updateArgsForCall = append(fake.updateArgsForCall, struct {
		arg1 context.Context
		arg2 *model.SignatureRequest
	}{arg1, arg2})
	stub := fake.UpdateStub
	fakeReturns := fake.updateReturns
	fake.recordInvocation("Update", []interface{}{arg1, arg2})
	fake.updateMutex.Unlock()
	if stub != nil {
		return stub(arg1, arg2)
	}
	if specificReturn {
		return ret.result1
	}
	return fakeReturns.result1
}

func (fake *FakeRepository) UpdateCallCount() int {
	fake.updateMutex.RLock()
	defer fake.updateMutex.RUnlock()
	return len(fake.updateArgsForCall)
}

func (fake *FakeRepository) UpdateCalls(stub func(context.Context, *model.SignatureRequest) error) {
	fake.updateMutex.Lock()
	defer fake.updateMutex.Unlock()
	fake.UpdateStub = stub
}

func (fake *FakeRepository) UpdateArgsForCall(i int) (context.Context, *model.SignatureRequest) {
	fake.updateMutex.RLock()
	defer fake.updateMutex.RUnlock()
	argsForCall := fake.updateArgsForCall[i]
	return argsForCall.arg1, argsForCall.arg2
}

func (fake *FakeRepository) UpdateReturns(result1 error) {
	fake.updateMutex.Lock()
	defer fake.updateMutex.Unlock()
	fake.UpdateStub = nil
	fake.updateReturns = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) UpdateReturnsOnCall(i int, result1 error) {
	fake.updateMutex.Lock()
	defer fake.updateMutex.Unlock()
	fake.UpdateStub = nil
	if fake.updateReturnsOnCall == nil {
		fake.updateReturnsOnCall = make(map[int]struct {
			result1 error
		})
	}
	fake.updateReturnsOnCall[i] = struct {
		result1 error
	}{result1}
}

func (fake *FakeRepository) Invocations() map[string][][]interface{} {
	fake.invocationsMutex.RLock()
	defer fake.invocationsMutex.RUnlock()
	fake.createMutex.RLock()
	defer fake.createMutex.RUnlock()
	fake.createTokenMutex.RLock()
	defer fake.createTokenMutex.RUnlock()
	fake.deleteAccessByFileIDMutex.RLock()
	defer fake.deleteAccessByFileIDMutex.RUnlock()
	fake.deleteByFileIDAndSignerUIDMutex.RLock()
	defer fake.deleteByFileIDAndSignerUIDMutex.RUnlock()
	fake.deleteByIDMutex.RLock()
	defer fake.deleteByIDMutex.RUnlock()
	fake.deleteTokensMutex.RLock()
	defer fake.deleteTokensMutex.RUnlock()
	fake.findActiveForOrganizationMutex.RLock()
	defer fake.findActiveForOrganizationMutex.RUnlock()
	fake.findAllForOrganizationMutex.RLock()
	defer fake.findAllForOrganizationMutex.RUnlock()
	fake.findAllForSignerMutex.RLock()
	defer fake.findAllForSignerMutex.RUnlock()
	fake.findByDocumentIDAndSignerUIDMutex.RLock()
	defer fake.findByDocumentIDAndSignerUIDMutex.RUnlock()
	fake.findByFileIDMutex.RLock()
	defer fake.findByFileIDMutex.RUnlock()
	fake.findByFileIDAndSignerUIDMutex.RLock()
	defer fake.findByFileIDAndSignerUIDMutex.RUnlock()
	fake.findByFileIDsAndSignerMutex.RLock()
	defer fake.findByFileIDsAndSignerMutex.RUnlock()
	fake.findByHashedSignerTokenMutex.RLock()
	defer fake.findByHashedSignerTokenMutex.RUnlock()
	fake.findByIDMutex.RLock()
	defer fake.findByIDMutex.RUnlock()
	fake.findByIDForSignerUIDMutex.RLock()
	defer fake.findByIDForSignerUIDMutex.RUnlock()
	fake.findByProcessIDMutex.RLock()
	defer fake.findByProcessIDMutex.RUnlock()
	fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RLock()
	defer fake.findByRequestorCreatedBeforeNotAnonymizedForUpdateMutex.RUnlock()
	fake.findBySignerUIDMutex.RLock()
	defer fake.findBySignerUIDMutex.RUnlock()
	fake.findBySignerWithNameOrEmailLikeMutex.RLock()
	defer fake.findBySignerWithNameOrEmailLikeMutex.RUnlock()
	fake.findCompletedForOrganizationMutex.RLock()
	defer fake.findCompletedForOrganizationMutex.RUnlock()
	fake.findExpiredBeforeMutex.RLock()
	defer fake.findExpiredBeforeMutex.RUnlock()
	fake.findExpiredByFileIdMutex.RLock()
	defer fake.findExpiredByFileIdMutex.RUnlock()
	fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RLock()
	defer fake.findUnsignedBeforeAndRemindersSentLessOrEqualThanAndNotCancelledMutex.RUnlock()
	fake.updateMutex.RLock()
	defer fake.updateMutex.RUnlock()
	copiedInvocations := map[string][][]interface{}{}
	for key, value := range fake.invocations {
		copiedInvocations[key] = value
	}
	return copiedInvocations
}

func (fake *FakeRepository) 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 _ repository.Repository = new(FakeRepository)