github.com/go-generalize/volcago@v1.7.0/generator/testfiles/auto/mock/mock_lock_gen/mock_lock_gen.go

// Code generated by MockGen. DO NOT EDIT.
// Source: lock_gen.go

// Package mock_model is a generated GoMock package.
package mock_model

import (
	context "context"
	reflect "reflect"

	firestore "cloud.google.com/go/firestore"
	model "github.com/go-generalize/volcago/generator/testfiles/auto"
	gomock "github.com/golang/mock/gomock"
)

// MockLockRepository is a mock of LockRepository interface.
type MockLockRepository struct {
	ctrl     *gomock.Controller
	recorder *MockLockRepositoryMockRecorder
}

// MockLockRepositoryMockRecorder is the mock recorder for MockLockRepository.
type MockLockRepositoryMockRecorder struct {
	mock *MockLockRepository
}

// NewMockLockRepository creates a new mock instance.
func NewMockLockRepository(ctrl *gomock.Controller) *MockLockRepository {
	mock := &MockLockRepository{ctrl: ctrl}
	mock.recorder = &MockLockRepositoryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLockRepository) EXPECT() *MockLockRepositoryMockRecorder {
	return m.recorder
}

// Delete mocks base method.
func (m *MockLockRepository) Delete(ctx context.Context, subject *model.Lock, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, subject}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockLockRepositoryMockRecorder) Delete(ctx, subject interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, subject}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockLockRepository)(nil).Delete), varargs...)
}

// DeleteByID mocks base method.
func (m *MockLockRepository) DeleteByID(ctx context.Context, id string, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteByID", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteByID indicates an expected call of DeleteByID.
func (mr *MockLockRepositoryMockRecorder) DeleteByID(ctx, id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByID", reflect.TypeOf((*MockLockRepository)(nil).DeleteByID), varargs...)
}

// DeleteByIDWithTx mocks base method.
func (m *MockLockRepository) DeleteByIDWithTx(ctx context.Context, tx *firestore.Transaction, id string, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, tx, id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteByIDWithTx", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteByIDWithTx indicates an expected call of DeleteByIDWithTx.
func (mr *MockLockRepositoryMockRecorder) DeleteByIDWithTx(ctx, tx, id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, tx, id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteByIDWithTx", reflect.TypeOf((*MockLockRepository)(nil).DeleteByIDWithTx), varargs...)
}

// DeleteMulti mocks base method.
func (m *MockLockRepository) DeleteMulti(ctx context.Context, subjects []*model.Lock, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, subjects}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMulti", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMulti indicates an expected call of DeleteMulti.
func (mr *MockLockRepositoryMockRecorder) DeleteMulti(ctx, subjects interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, subjects}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMulti", reflect.TypeOf((*MockLockRepository)(nil).DeleteMulti), varargs...)
}

// DeleteMultiByIDs mocks base method.
func (m *MockLockRepository) DeleteMultiByIDs(ctx context.Context, ids []string, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, ids}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMultiByIDs", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMultiByIDs indicates an expected call of DeleteMultiByIDs.
func (mr *MockLockRepositoryMockRecorder) DeleteMultiByIDs(ctx, ids interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, ids}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultiByIDs", reflect.TypeOf((*MockLockRepository)(nil).DeleteMultiByIDs), varargs...)
}

// DeleteMultiByIDsWithTx mocks base method.
func (m *MockLockRepository) DeleteMultiByIDsWithTx(ctx context.Context, tx *firestore.Transaction, ids []string, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, tx, ids}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMultiByIDsWithTx", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMultiByIDsWithTx indicates an expected call of DeleteMultiByIDsWithTx.
func (mr *MockLockRepositoryMockRecorder) DeleteMultiByIDsWithTx(ctx, tx, ids interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, tx, ids}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultiByIDsWithTx", reflect.TypeOf((*MockLockRepository)(nil).DeleteMultiByIDsWithTx), varargs...)
}

// DeleteMultiWithTx mocks base method.
func (m *MockLockRepository) DeleteMultiWithTx(ctx context.Context, tx *firestore.Transaction, subjects []*model.Lock, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, tx, subjects}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMultiWithTx", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMultiWithTx indicates an expected call of DeleteMultiWithTx.
func (mr *MockLockRepositoryMockRecorder) DeleteMultiWithTx(ctx, tx, subjects interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, tx, subjects}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultiWithTx", reflect.TypeOf((*MockLockRepository)(nil).DeleteMultiWithTx), varargs...)
}

// DeleteWithTx mocks base method.
func (m *MockLockRepository) DeleteWithTx(ctx context.Context, tx *firestore.Transaction, subject *model.Lock, opts ...model.DeleteOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, tx, subject}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteWithTx", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteWithTx indicates an expected call of DeleteWithTx.
func (mr *MockLockRepositoryMockRecorder) DeleteWithTx(ctx, tx, subject interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, tx, subject}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteWithTx", reflect.TypeOf((*MockLockRepository)(nil).DeleteWithTx), varargs...)
}

// Get mocks base method.
func (m *MockLockRepository) Get(ctx context.Context, id string, opts ...model.GetOption) (*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Get", varargs...)
	ret0, _ := ret[0].(*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockLockRepositoryMockRecorder) Get(ctx, id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockLockRepository)(nil).Get), varargs...)
}

// GetByText2 mocks base method.
func (m *MockLockRepository) GetByText2(ctx context.Context, text2 string, opts ...model.GetOption) (*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, text2}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetByText2", varargs...)
	ret0, _ := ret[0].(*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByText2 indicates an expected call of GetByText2.
func (mr *MockLockRepositoryMockRecorder) GetByText2(ctx, text2 interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, text2}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByText2", reflect.TypeOf((*MockLockRepository)(nil).GetByText2), varargs...)
}

// GetByText2WithTx mocks base method.
func (m *MockLockRepository) GetByText2WithTx(tx *firestore.Transaction, text2 string, opts ...model.GetOption) (*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{tx, text2}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetByText2WithTx", varargs...)
	ret0, _ := ret[0].(*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetByText2WithTx indicates an expected call of GetByText2WithTx.
func (mr *MockLockRepositoryMockRecorder) GetByText2WithTx(tx, text2 interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{tx, text2}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByText2WithTx", reflect.TypeOf((*MockLockRepository)(nil).GetByText2WithTx), varargs...)
}

// GetCollection mocks base method.
func (m *MockLockRepository) GetCollection() *firestore.CollectionRef {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCollection")
	ret0, _ := ret[0].(*firestore.CollectionRef)
	return ret0
}

// GetCollection indicates an expected call of GetCollection.
func (mr *MockLockRepositoryMockRecorder) GetCollection() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCollection", reflect.TypeOf((*MockLockRepository)(nil).GetCollection))
}

// GetCollectionName mocks base method.
func (m *MockLockRepository) GetCollectionName() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCollectionName")
	ret0, _ := ret[0].(string)
	return ret0
}

// GetCollectionName indicates an expected call of GetCollectionName.
func (mr *MockLockRepositoryMockRecorder) GetCollectionName() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCollectionName", reflect.TypeOf((*MockLockRepository)(nil).GetCollectionName))
}

// GetDocRef mocks base method.
func (m *MockLockRepository) GetDocRef(id string) *firestore.DocumentRef {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDocRef", id)
	ret0, _ := ret[0].(*firestore.DocumentRef)
	return ret0
}

// GetDocRef indicates an expected call of GetDocRef.
func (mr *MockLockRepositoryMockRecorder) GetDocRef(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocRef", reflect.TypeOf((*MockLockRepository)(nil).GetDocRef), id)
}

// GetMulti mocks base method.
func (m *MockLockRepository) GetMulti(ctx context.Context, ids []string, opts ...model.GetOption) ([]*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, ids}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMulti", varargs...)
	ret0, _ := ret[0].([]*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMulti indicates an expected call of GetMulti.
func (mr *MockLockRepositoryMockRecorder) GetMulti(ctx, ids interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, ids}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMulti", reflect.TypeOf((*MockLockRepository)(nil).GetMulti), varargs...)
}

// GetMultiWithTx mocks base method.
func (m *MockLockRepository) GetMultiWithTx(tx *firestore.Transaction, ids []string, opts ...model.GetOption) ([]*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{tx, ids}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMultiWithTx", varargs...)
	ret0, _ := ret[0].([]*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMultiWithTx indicates an expected call of GetMultiWithTx.
func (mr *MockLockRepositoryMockRecorder) GetMultiWithTx(tx, ids interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{tx, ids}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMultiWithTx", reflect.TypeOf((*MockLockRepository)(nil).GetMultiWithTx), varargs...)
}

// GetWithDoc mocks base method.
func (m *MockLockRepository) GetWithDoc(ctx context.Context, doc *firestore.DocumentRef, opts ...model.GetOption) (*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, doc}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWithDoc", varargs...)
	ret0, _ := ret[0].(*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWithDoc indicates an expected call of GetWithDoc.
func (mr *MockLockRepositoryMockRecorder) GetWithDoc(ctx, doc interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, doc}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWithDoc", reflect.TypeOf((*MockLockRepository)(nil).GetWithDoc), varargs...)
}

// GetWithDocWithTx mocks base method.
func (m *MockLockRepository) GetWithDocWithTx(tx *firestore.Transaction, doc *firestore.DocumentRef, opts ...model.GetOption) (*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{tx, doc}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWithDocWithTx", varargs...)
	ret0, _ := ret[0].(*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWithDocWithTx indicates an expected call of GetWithDocWithTx.
func (mr *MockLockRepositoryMockRecorder) GetWithDocWithTx(tx, doc interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{tx, doc}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWithDocWithTx", reflect.TypeOf((*MockLockRepository)(nil).GetWithDocWithTx), varargs...)
}

// GetWithTx mocks base method.
func (m *MockLockRepository) GetWithTx(tx *firestore.Transaction, id string, opts ...model.GetOption) (*model.Lock, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{tx, id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetWithTx", varargs...)
	ret0, _ := ret[0].(*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetWithTx indicates an expected call of GetWithTx.
func (mr *MockLockRepositoryMockRecorder) GetWithTx(tx, id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{tx, id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetWithTx", reflect.TypeOf((*MockLockRepository)(nil).GetWithTx), varargs...)
}

// Insert mocks base method.
func (m *MockLockRepository) Insert(ctx context.Context, subject *model.Lock) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", ctx, subject)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Insert indicates an expected call of Insert.
func (mr *MockLockRepositoryMockRecorder) Insert(ctx, subject interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Insert", reflect.TypeOf((*MockLockRepository)(nil).Insert), ctx, subject)
}

// InsertMulti mocks base method.
func (m *MockLockRepository) InsertMulti(ctx context.Context, subjects []*model.Lock) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertMulti", ctx, subjects)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMulti indicates an expected call of InsertMulti.
func (mr *MockLockRepositoryMockRecorder) InsertMulti(ctx, subjects interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMulti", reflect.TypeOf((*MockLockRepository)(nil).InsertMulti), ctx, subjects)
}

// InsertMultiWithTx mocks base method.
func (m *MockLockRepository) InsertMultiWithTx(ctx context.Context, tx *firestore.Transaction, subjects []*model.Lock) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertMultiWithTx", ctx, tx, subjects)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMultiWithTx indicates an expected call of InsertMultiWithTx.
func (mr *MockLockRepositoryMockRecorder) InsertMultiWithTx(ctx, tx, subjects interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMultiWithTx", reflect.TypeOf((*MockLockRepository)(nil).InsertMultiWithTx), ctx, tx, subjects)
}

// InsertWithTx mocks base method.
func (m *MockLockRepository) InsertWithTx(ctx context.Context, tx *firestore.Transaction, subject *model.Lock) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertWithTx", ctx, tx, subject)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertWithTx indicates an expected call of InsertWithTx.
func (mr *MockLockRepositoryMockRecorder) InsertWithTx(ctx, tx, subject interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertWithTx", reflect.TypeOf((*MockLockRepository)(nil).InsertWithTx), ctx, tx, subject)
}

// RunInTransaction mocks base method.
func (m *MockLockRepository) RunInTransaction() func(context.Context, func(context.Context, *firestore.Transaction) error, ...firestore.TransactionOption) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RunInTransaction")
	ret0, _ := ret[0].(func(context.Context, func(context.Context, *firestore.Transaction) error, ...firestore.TransactionOption) error)
	return ret0
}

// RunInTransaction indicates an expected call of RunInTransaction.
func (mr *MockLockRepositoryMockRecorder) RunInTransaction() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInTransaction", reflect.TypeOf((*MockLockRepository)(nil).RunInTransaction))
}

// Search mocks base method.
func (m *MockLockRepository) Search(ctx context.Context, param *model.LockSearchParam, q *firestore.Query) ([]*model.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Search", ctx, param, q)
	ret0, _ := ret[0].([]*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Search indicates an expected call of Search.
func (mr *MockLockRepositoryMockRecorder) Search(ctx, param, q interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Search", reflect.TypeOf((*MockLockRepository)(nil).Search), ctx, param, q)
}

// SearchByParam mocks base method.
func (m *MockLockRepository) SearchByParam(ctx context.Context, param *model.LockSearchParam) ([]*model.Lock, *model.PagingResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchByParam", ctx, param)
	ret0, _ := ret[0].([]*model.Lock)
	ret1, _ := ret[1].(*model.PagingResult)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SearchByParam indicates an expected call of SearchByParam.
func (mr *MockLockRepositoryMockRecorder) SearchByParam(ctx, param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchByParam", reflect.TypeOf((*MockLockRepository)(nil).SearchByParam), ctx, param)
}

// SearchByParamWithTx mocks base method.
func (m *MockLockRepository) SearchByParamWithTx(tx *firestore.Transaction, param *model.LockSearchParam) ([]*model.Lock, *model.PagingResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchByParamWithTx", tx, param)
	ret0, _ := ret[0].([]*model.Lock)
	ret1, _ := ret[1].(*model.PagingResult)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SearchByParamWithTx indicates an expected call of SearchByParamWithTx.
func (mr *MockLockRepositoryMockRecorder) SearchByParamWithTx(tx, param interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchByParamWithTx", reflect.TypeOf((*MockLockRepository)(nil).SearchByParamWithTx), tx, param)
}

// SearchWithTx mocks base method.
func (m *MockLockRepository) SearchWithTx(tx *firestore.Transaction, param *model.LockSearchParam, q *firestore.Query) ([]*model.Lock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchWithTx", tx, param, q)
	ret0, _ := ret[0].([]*model.Lock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SearchWithTx indicates an expected call of SearchWithTx.
func (mr *MockLockRepositoryMockRecorder) SearchWithTx(tx, param, q interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchWithTx", reflect.TypeOf((*MockLockRepository)(nil).SearchWithTx), tx, param, q)
}

// StrictUpdate mocks base method.
func (m *MockLockRepository) StrictUpdate(ctx context.Context, id string, param *model.LockUpdateParam, opts ...firestore.Precondition) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, id, param}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StrictUpdate", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// StrictUpdate indicates an expected call of StrictUpdate.
func (mr *MockLockRepositoryMockRecorder) StrictUpdate(ctx, id, param interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, id, param}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrictUpdate", reflect.TypeOf((*MockLockRepository)(nil).StrictUpdate), varargs...)
}

// StrictUpdateWithTx mocks base method.
func (m *MockLockRepository) StrictUpdateWithTx(tx *firestore.Transaction, id string, param *model.LockUpdateParam, opts ...firestore.Precondition) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{tx, id, param}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StrictUpdateWithTx", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// StrictUpdateWithTx indicates an expected call of StrictUpdateWithTx.
func (mr *MockLockRepositoryMockRecorder) StrictUpdateWithTx(tx, id, param interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{tx, id, param}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StrictUpdateWithTx", reflect.TypeOf((*MockLockRepository)(nil).StrictUpdateWithTx), varargs...)
}

// Update mocks base method.
func (m *MockLockRepository) Update(ctx context.Context, subject *model.Lock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", ctx, subject)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockLockRepositoryMockRecorder) Update(ctx, subject interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockLockRepository)(nil).Update), ctx, subject)
}

// UpdateMulti mocks base method.
func (m *MockLockRepository) UpdateMulti(ctx context.Context, subjects []*model.Lock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMulti", ctx, subjects)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMulti indicates an expected call of UpdateMulti.
func (mr *MockLockRepositoryMockRecorder) UpdateMulti(ctx, subjects interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMulti", reflect.TypeOf((*MockLockRepository)(nil).UpdateMulti), ctx, subjects)
}

// UpdateMultiWithTx mocks base method.
func (m *MockLockRepository) UpdateMultiWithTx(ctx context.Context, tx *firestore.Transaction, subjects []*model.Lock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMultiWithTx", ctx, tx, subjects)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateMultiWithTx indicates an expected call of UpdateMultiWithTx.
func (mr *MockLockRepositoryMockRecorder) UpdateMultiWithTx(ctx, tx, subjects interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMultiWithTx", reflect.TypeOf((*MockLockRepository)(nil).UpdateMultiWithTx), ctx, tx, subjects)
}

// UpdateWithTx mocks base method.
func (m *MockLockRepository) UpdateWithTx(ctx context.Context, tx *firestore.Transaction, subject *model.Lock) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateWithTx", ctx, tx, subject)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateWithTx indicates an expected call of UpdateWithTx.
func (mr *MockLockRepositoryMockRecorder) UpdateWithTx(ctx, tx, subject interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateWithTx", reflect.TypeOf((*MockLockRepository)(nil).UpdateWithTx), ctx, tx, subject)
}

// MockLockRepositoryMiddleware is a mock of LockRepositoryMiddleware interface.
type MockLockRepositoryMiddleware struct {
	ctrl     *gomock.Controller
	recorder *MockLockRepositoryMiddlewareMockRecorder
}

// MockLockRepositoryMiddlewareMockRecorder is the mock recorder for MockLockRepositoryMiddleware.
type MockLockRepositoryMiddlewareMockRecorder struct {
	mock *MockLockRepositoryMiddleware
}

// NewMockLockRepositoryMiddleware creates a new mock instance.
func NewMockLockRepositoryMiddleware(ctrl *gomock.Controller) *MockLockRepositoryMiddleware {
	mock := &MockLockRepositoryMiddleware{ctrl: ctrl}
	mock.recorder = &MockLockRepositoryMiddlewareMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockLockRepositoryMiddleware) EXPECT() *MockLockRepositoryMiddlewareMockRecorder {
	return m.recorder
}

// BeforeDelete mocks base method.
func (m *MockLockRepositoryMiddleware) BeforeDelete(ctx context.Context, subject *model.Lock, opts ...model.DeleteOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, subject}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BeforeDelete", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeforeDelete indicates an expected call of BeforeDelete.
func (mr *MockLockRepositoryMiddlewareMockRecorder) BeforeDelete(ctx, subject interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, subject}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeforeDelete", reflect.TypeOf((*MockLockRepositoryMiddleware)(nil).BeforeDelete), varargs...)
}

// BeforeDeleteByID mocks base method.
func (m *MockLockRepositoryMiddleware) BeforeDeleteByID(ctx context.Context, ids []string, opts ...model.DeleteOption) (bool, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{ctx, ids}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BeforeDeleteByID", varargs...)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeforeDeleteByID indicates an expected call of BeforeDeleteByID.
func (mr *MockLockRepositoryMiddlewareMockRecorder) BeforeDeleteByID(ctx, ids interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{ctx, ids}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeforeDeleteByID", reflect.TypeOf((*MockLockRepositoryMiddleware)(nil).BeforeDeleteByID), varargs...)
}

// BeforeInsert mocks base method.
func (m *MockLockRepositoryMiddleware) BeforeInsert(ctx context.Context, subject *model.Lock) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeforeInsert", ctx, subject)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeforeInsert indicates an expected call of BeforeInsert.
func (mr *MockLockRepositoryMiddlewareMockRecorder) BeforeInsert(ctx, subject interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeforeInsert", reflect.TypeOf((*MockLockRepositoryMiddleware)(nil).BeforeInsert), ctx, subject)
}

// BeforeUpdate mocks base method.
func (m *MockLockRepositoryMiddleware) BeforeUpdate(ctx context.Context, old, subject *model.Lock) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeforeUpdate", ctx, old, subject)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BeforeUpdate indicates an expected call of BeforeUpdate.
func (mr *MockLockRepositoryMiddlewareMockRecorder) BeforeUpdate(ctx, old, subject interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeforeUpdate", reflect.TypeOf((*MockLockRepositoryMiddleware)(nil).BeforeUpdate), ctx, old, subject)
}