// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/itsscb/df/bff/db/sqlc (interfaces: Store)
//
// Generated by this command:
//
//	mockgen -package mockdb -destination db/mock/store.go github.com/itsscb/df/bff/db/sqlc Store
//
// Package mockdb is a generated GoMock package.
package mockdb

import (
	context "context"
	sql "database/sql"
	reflect "reflect"

	uuid "github.com/google/uuid"
	db "github.com/itsscb/df/bff/db/sqlc"
	gomock "go.uber.org/mock/gomock"
	codes "google.golang.org/grpc/codes"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// BlockSession mocks base method.
func (m *MockStore) BlockSession(arg0 context.Context, arg1 uuid.UUID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockSession", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// BlockSession indicates an expected call of BlockSession.
func (mr *MockStoreMockRecorder) BlockSession(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockSession", reflect.TypeOf((*MockStore)(nil).BlockSession), arg0, arg1)
}

// CloneProviders mocks base method.
func (m *MockStore) CloneProviders(arg0 context.Context, arg1 db.CloneProvidersParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloneProviders", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// CloneProviders indicates an expected call of CloneProviders.
func (mr *MockStoreMockRecorder) CloneProviders(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloneProviders", reflect.TypeOf((*MockStore)(nil).CloneProviders), arg0, arg1)
}

// CreateAccount mocks base method.
func (m *MockStore) CreateAccount(arg0 context.Context, arg1 db.CreateAccountParams) (db.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccount", arg0, arg1)
	ret0, _ := ret[0].(db.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAccount indicates an expected call of CreateAccount.
func (mr *MockStoreMockRecorder) CreateAccount(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccount", reflect.TypeOf((*MockStore)(nil).CreateAccount), arg0, arg1)
}

// CreateAccountInfo mocks base method.
func (m *MockStore) CreateAccountInfo(arg0 context.Context, arg1 db.CreateAccountInfoParams) (db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountInfo", arg0, arg1)
	ret0, _ := ret[0].(db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAccountInfo indicates an expected call of CreateAccountInfo.
func (mr *MockStoreMockRecorder) CreateAccountInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccountInfo", reflect.TypeOf((*MockStore)(nil).CreateAccountInfo), arg0, arg1)
}

// CreateAccountTx mocks base method.
func (m *MockStore) CreateAccountTx(arg0 context.Context, arg1 db.CreateAccountTxParams) (db.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAccountTx", arg0, arg1)
	ret0, _ := ret[0].(db.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateAccountTx indicates an expected call of CreateAccountTx.
func (mr *MockStoreMockRecorder) CreateAccountTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateAccountTx", reflect.TypeOf((*MockStore)(nil).CreateAccountTx), arg0, arg1)
}

// CreateDocument mocks base method.
func (m *MockStore) CreateDocument(arg0 context.Context, arg1 db.CreateDocumentParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDocument", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDocument indicates an expected call of CreateDocument.
func (mr *MockStoreMockRecorder) CreateDocument(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocument", reflect.TypeOf((*MockStore)(nil).CreateDocument), arg0, arg1)
}

// CreateDocumentMail mocks base method.
func (m *MockStore) CreateDocumentMail(arg0 context.Context, arg1 db.CreateDocumentMailParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDocumentMail", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDocumentMail indicates an expected call of CreateDocumentMail.
func (mr *MockStoreMockRecorder) CreateDocumentMail(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocumentMail", reflect.TypeOf((*MockStore)(nil).CreateDocumentMail), arg0, arg1)
}

// CreateDocumentTx mocks base method.
func (m *MockStore) CreateDocumentTx(arg0 context.Context, arg1 db.CreateDocumentTxParams) (db.Document, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDocumentTx", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateDocumentTx indicates an expected call of CreateDocumentTx.
func (mr *MockStoreMockRecorder) CreateDocumentTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocumentTx", reflect.TypeOf((*MockStore)(nil).CreateDocumentTx), arg0, arg1)
}

// CreateDocumentUpload mocks base method.
func (m *MockStore) CreateDocumentUpload(arg0 context.Context, arg1 db.CreateDocumentUploadParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateDocumentUpload", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateDocumentUpload indicates an expected call of CreateDocumentUpload.
func (mr *MockStoreMockRecorder) CreateDocumentUpload(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDocumentUpload", reflect.TypeOf((*MockStore)(nil).CreateDocumentUpload), arg0, arg1)
}

// CreateMail mocks base method.
func (m *MockStore) CreateMail(arg0 context.Context, arg1 db.CreateMailParams) (db.Mail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateMail", arg0, arg1)
	ret0, _ := ret[0].(db.Mail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateMail indicates an expected call of CreateMail.
func (mr *MockStoreMockRecorder) CreateMail(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMail", reflect.TypeOf((*MockStore)(nil).CreateMail), arg0, arg1)
}

// CreatePayment mocks base method.
func (m *MockStore) CreatePayment(arg0 context.Context, arg1 db.CreatePaymentParams) (db.Payment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePayment", arg0, arg1)
	ret0, _ := ret[0].(db.Payment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePayment indicates an expected call of CreatePayment.
func (mr *MockStoreMockRecorder) CreatePayment(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePayment", reflect.TypeOf((*MockStore)(nil).CreatePayment), arg0, arg1)
}

// CreatePerson mocks base method.
func (m *MockStore) CreatePerson(arg0 context.Context, arg1 db.CreatePersonParams) (db.Person, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePerson", arg0, arg1)
	ret0, _ := ret[0].(db.Person)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePerson indicates an expected call of CreatePerson.
func (mr *MockStoreMockRecorder) CreatePerson(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePerson", reflect.TypeOf((*MockStore)(nil).CreatePerson), arg0, arg1)
}

// CreatePersonTx mocks base method.
func (m *MockStore) CreatePersonTx(arg0 context.Context, arg1 db.CreatePersonTxParams) (db.Person, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePersonTx", arg0, arg1)
	ret0, _ := ret[0].(db.Person)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePersonTx indicates an expected call of CreatePersonTx.
func (mr *MockStoreMockRecorder) CreatePersonTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePersonTx", reflect.TypeOf((*MockStore)(nil).CreatePersonTx), arg0, arg1)
}

// CreateProvider mocks base method.
func (m *MockStore) CreateProvider(arg0 context.Context, arg1 db.CreateProviderParams) (db.Provider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateProvider", arg0, arg1)
	ret0, _ := ret[0].(db.Provider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateProvider indicates an expected call of CreateProvider.
func (mr *MockStoreMockRecorder) CreateProvider(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateProvider", reflect.TypeOf((*MockStore)(nil).CreateProvider), arg0, arg1)
}

// CreateReturn mocks base method.
func (m *MockStore) CreateReturn(arg0 context.Context, arg1 db.CreateReturnParams) (db.Return, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReturn", arg0, arg1)
	ret0, _ := ret[0].(db.Return)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReturn indicates an expected call of CreateReturn.
func (mr *MockStoreMockRecorder) CreateReturn(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReturn", reflect.TypeOf((*MockStore)(nil).CreateReturn), arg0, arg1)
}

// CreateReturnsLog mocks base method.
func (m *MockStore) CreateReturnsLog(arg0 context.Context, arg1 db.CreateReturnsLogParams) (db.ReturnsLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateReturnsLog", arg0, arg1)
	ret0, _ := ret[0].(db.ReturnsLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateReturnsLog indicates an expected call of CreateReturnsLog.
func (mr *MockStoreMockRecorder) CreateReturnsLog(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReturnsLog", reflect.TypeOf((*MockStore)(nil).CreateReturnsLog), arg0, arg1)
}

// CreateSession mocks base method.
func (m *MockStore) CreateSession(arg0 context.Context, arg1 db.CreateSessionParams) (db.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateSession", arg0, arg1)
	ret0, _ := ret[0].(db.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSession indicates an expected call of CreateSession.
func (mr *MockStoreMockRecorder) CreateSession(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSession", reflect.TypeOf((*MockStore)(nil).CreateSession), arg0, arg1)
}

// DeleteAccount mocks base method.
func (m *MockStore) DeleteAccount(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccount", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAccount indicates an expected call of DeleteAccount.
func (mr *MockStoreMockRecorder) DeleteAccount(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccount", reflect.TypeOf((*MockStore)(nil).DeleteAccount), arg0, arg1)
}

// DeleteAccountInfo mocks base method.
func (m *MockStore) DeleteAccountInfo(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAccountInfo", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteAccountInfo indicates an expected call of DeleteAccountInfo.
func (mr *MockStoreMockRecorder) DeleteAccountInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAccountInfo", reflect.TypeOf((*MockStore)(nil).DeleteAccountInfo), arg0, arg1)
}

// DeleteDocument mocks base method.
func (m *MockStore) DeleteDocument(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDocument", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDocument indicates an expected call of DeleteDocument.
func (mr *MockStoreMockRecorder) DeleteDocument(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocument", reflect.TypeOf((*MockStore)(nil).DeleteDocument), arg0, arg1)
}

// DeleteDocumentTx mocks base method.
func (m *MockStore) DeleteDocumentTx(arg0 context.Context, arg1 uint64) (codes.Code, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDocumentTx", arg0, arg1)
	ret0, _ := ret[0].(codes.Code)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteDocumentTx indicates an expected call of DeleteDocumentTx.
func (mr *MockStoreMockRecorder) DeleteDocumentTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocumentTx", reflect.TypeOf((*MockStore)(nil).DeleteDocumentTx), arg0, arg1)
}

// DeleteDocumentsByPersonID mocks base method.
func (m *MockStore) DeleteDocumentsByPersonID(arg0 context.Context, arg1 sql.NullInt64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteDocumentsByPersonID", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteDocumentsByPersonID indicates an expected call of DeleteDocumentsByPersonID.
func (mr *MockStoreMockRecorder) DeleteDocumentsByPersonID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDocumentsByPersonID", reflect.TypeOf((*MockStore)(nil).DeleteDocumentsByPersonID), arg0, arg1)
}

// DeleteMail mocks base method.
func (m *MockStore) DeleteMail(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteMail", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteMail indicates an expected call of DeleteMail.
func (mr *MockStoreMockRecorder) DeleteMail(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMail", reflect.TypeOf((*MockStore)(nil).DeleteMail), arg0, arg1)
}

// DeletePayment mocks base method.
func (m *MockStore) DeletePayment(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePayment", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePayment indicates an expected call of DeletePayment.
func (mr *MockStoreMockRecorder) DeletePayment(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePayment", reflect.TypeOf((*MockStore)(nil).DeletePayment), arg0, arg1)
}

// DeletePerson mocks base method.
func (m *MockStore) DeletePerson(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePerson", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePerson indicates an expected call of DeletePerson.
func (mr *MockStoreMockRecorder) DeletePerson(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePerson", reflect.TypeOf((*MockStore)(nil).DeletePerson), arg0, arg1)
}

// DeletePersonTx mocks base method.
func (m *MockStore) DeletePersonTx(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePersonTx", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeletePersonTx indicates an expected call of DeletePersonTx.
func (mr *MockStoreMockRecorder) DeletePersonTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePersonTx", reflect.TypeOf((*MockStore)(nil).DeletePersonTx), arg0, arg1)
}

// DeleteProvider mocks base method.
func (m *MockStore) DeleteProvider(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProvider", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProvider indicates an expected call of DeleteProvider.
func (mr *MockStoreMockRecorder) DeleteProvider(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProvider", reflect.TypeOf((*MockStore)(nil).DeleteProvider), arg0, arg1)
}

// DeleteReturn mocks base method.
func (m *MockStore) DeleteReturn(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReturn", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReturn indicates an expected call of DeleteReturn.
func (mr *MockStoreMockRecorder) DeleteReturn(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReturn", reflect.TypeOf((*MockStore)(nil).DeleteReturn), arg0, arg1)
}

// DeleteReturnsByPersonID mocks base method.
func (m *MockStore) DeleteReturnsByPersonID(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReturnsByPersonID", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReturnsByPersonID indicates an expected call of DeleteReturnsByPersonID.
func (mr *MockStoreMockRecorder) DeleteReturnsByPersonID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReturnsByPersonID", reflect.TypeOf((*MockStore)(nil).DeleteReturnsByPersonID), arg0, arg1)
}

// DeleteReturnsLog mocks base method.
func (m *MockStore) DeleteReturnsLog(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReturnsLog", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReturnsLog indicates an expected call of DeleteReturnsLog.
func (mr *MockStoreMockRecorder) DeleteReturnsLog(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReturnsLog", reflect.TypeOf((*MockStore)(nil).DeleteReturnsLog), arg0, arg1)
}

// DeleteReturnsLogsByPersonID mocks base method.
func (m *MockStore) DeleteReturnsLogsByPersonID(arg0 context.Context, arg1 uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteReturnsLogsByPersonID", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteReturnsLogsByPersonID indicates an expected call of DeleteReturnsLogsByPersonID.
func (mr *MockStoreMockRecorder) DeleteReturnsLogsByPersonID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteReturnsLogsByPersonID", reflect.TypeOf((*MockStore)(nil).DeleteReturnsLogsByPersonID), arg0, arg1)
}

// GetAccount mocks base method.
func (m *MockStore) GetAccount(arg0 context.Context, arg1 uint64) (db.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccount", arg0, arg1)
	ret0, _ := ret[0].(db.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccount indicates an expected call of GetAccount.
func (mr *MockStoreMockRecorder) GetAccount(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockStore)(nil).GetAccount), arg0, arg1)
}

// GetAccountByEmail mocks base method.
func (m *MockStore) GetAccountByEmail(arg0 context.Context, arg1 string) (db.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountByEmail", arg0, arg1)
	ret0, _ := ret[0].(db.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountByEmail indicates an expected call of GetAccountByEmail.
func (mr *MockStoreMockRecorder) GetAccountByEmail(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountByEmail", reflect.TypeOf((*MockStore)(nil).GetAccountByEmail), arg0, arg1)
}

// GetAccountInfo mocks base method.
func (m *MockStore) GetAccountInfo(arg0 context.Context, arg1 uint64) (db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccountInfo", arg0, arg1)
	ret0, _ := ret[0].(db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAccountInfo indicates an expected call of GetAccountInfo.
func (mr *MockStoreMockRecorder) GetAccountInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccountInfo", reflect.TypeOf((*MockStore)(nil).GetAccountInfo), arg0, arg1)
}

// GetDocument mocks base method.
func (m *MockStore) GetDocument(arg0 context.Context, arg1 uint64) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDocument", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDocument indicates an expected call of GetDocument.
func (mr *MockStoreMockRecorder) GetDocument(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocument", reflect.TypeOf((*MockStore)(nil).GetDocument), arg0, arg1)
}

// GetDocumentByHash mocks base method.
func (m *MockStore) GetDocumentByHash(arg0 context.Context, arg1 db.GetDocumentByHashParams) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDocumentByHash", arg0, arg1)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDocumentByHash indicates an expected call of GetDocumentByHash.
func (mr *MockStoreMockRecorder) GetDocumentByHash(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocumentByHash", reflect.TypeOf((*MockStore)(nil).GetDocumentByHash), arg0, arg1)
}

// GetDocumentByIDWithAccountID mocks base method.
func (m *MockStore) GetDocumentByIDWithAccountID(arg0 context.Context, arg1 db.GetDocumentByIDWithAccountIDParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDocumentByIDWithAccountID", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDocumentByIDWithAccountID indicates an expected call of GetDocumentByIDWithAccountID.
func (mr *MockStoreMockRecorder) GetDocumentByIDWithAccountID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDocumentByIDWithAccountID", reflect.TypeOf((*MockStore)(nil).GetDocumentByIDWithAccountID), arg0, arg1)
}

// GetMail mocks base method.
func (m *MockStore) GetMail(arg0 context.Context, arg1 uint64) (db.Mail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMail", arg0, arg1)
	ret0, _ := ret[0].(db.Mail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMail indicates an expected call of GetMail.
func (mr *MockStoreMockRecorder) GetMail(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMail", reflect.TypeOf((*MockStore)(nil).GetMail), arg0, arg1)
}

// GetPayment mocks base method.
func (m *MockStore) GetPayment(arg0 context.Context, arg1 uint64) (db.Payment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPayment", arg0, arg1)
	ret0, _ := ret[0].(db.Payment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPayment indicates an expected call of GetPayment.
func (mr *MockStoreMockRecorder) GetPayment(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPayment", reflect.TypeOf((*MockStore)(nil).GetPayment), arg0, arg1)
}

// GetPerson mocks base method.
func (m *MockStore) GetPerson(arg0 context.Context, arg1 uint64) (db.Person, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPerson", arg0, arg1)
	ret0, _ := ret[0].(db.Person)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPerson indicates an expected call of GetPerson.
func (mr *MockStoreMockRecorder) GetPerson(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPerson", reflect.TypeOf((*MockStore)(nil).GetPerson), arg0, arg1)
}

// GetProvider mocks base method.
func (m *MockStore) GetProvider(arg0 context.Context, arg1 uint64) (db.Provider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvider", arg0, arg1)
	ret0, _ := ret[0].(db.Provider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvider indicates an expected call of GetProvider.
func (mr *MockStoreMockRecorder) GetProvider(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvider", reflect.TypeOf((*MockStore)(nil).GetProvider), arg0, arg1)
}

// GetQueryByName mocks base method.
func (m *MockStore) GetQueryByName(arg0 context.Context, arg1 string) (db.Query, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueryByName", arg0, arg1)
	ret0, _ := ret[0].(db.Query)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetQueryByName indicates an expected call of GetQueryByName.
func (mr *MockStoreMockRecorder) GetQueryByName(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueryByName", reflect.TypeOf((*MockStore)(nil).GetQueryByName), arg0, arg1)
}

// GetReturn mocks base method.
func (m *MockStore) GetReturn(arg0 context.Context, arg1 uint64) (db.Return, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReturn", arg0, arg1)
	ret0, _ := ret[0].(db.Return)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReturn indicates an expected call of GetReturn.
func (mr *MockStoreMockRecorder) GetReturn(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReturn", reflect.TypeOf((*MockStore)(nil).GetReturn), arg0, arg1)
}

// GetReturnIDsByPersonID mocks base method.
func (m *MockStore) GetReturnIDsByPersonID(arg0 context.Context, arg1 uint64) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReturnIDsByPersonID", arg0, arg1)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReturnIDsByPersonID indicates an expected call of GetReturnIDsByPersonID.
func (mr *MockStoreMockRecorder) GetReturnIDsByPersonID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReturnIDsByPersonID", reflect.TypeOf((*MockStore)(nil).GetReturnIDsByPersonID), arg0, arg1)
}

// GetReturns mocks base method.
func (m *MockStore) GetReturns(arg0 context.Context, arg1 uint64) ([]db.Return, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReturns", arg0, arg1)
	ret0, _ := ret[0].([]db.Return)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReturns indicates an expected call of GetReturns.
func (mr *MockStoreMockRecorder) GetReturns(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReturns", reflect.TypeOf((*MockStore)(nil).GetReturns), arg0, arg1)
}

// GetReturnsLog mocks base method.
func (m *MockStore) GetReturnsLog(arg0 context.Context, arg1 uint64) (db.ReturnsLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetReturnsLog", arg0, arg1)
	ret0, _ := ret[0].(db.ReturnsLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetReturnsLog indicates an expected call of GetReturnsLog.
func (mr *MockStoreMockRecorder) GetReturnsLog(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReturnsLog", reflect.TypeOf((*MockStore)(nil).GetReturnsLog), arg0, arg1)
}

// GetSession mocks base method.
func (m *MockStore) GetSession(arg0 context.Context, arg1 uuid.UUID) (db.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSession", arg0, arg1)
	ret0, _ := ret[0].(db.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSession indicates an expected call of GetSession.
func (mr *MockStoreMockRecorder) GetSession(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSession", reflect.TypeOf((*MockStore)(nil).GetSession), arg0, arg1)
}

// InvalidateDocument mocks base method.
func (m *MockStore) InvalidateDocument(arg0 context.Context, arg1 db.InvalidateDocumentParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InvalidateDocument", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InvalidateDocument indicates an expected call of InvalidateDocument.
func (mr *MockStoreMockRecorder) InvalidateDocument(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InvalidateDocument", reflect.TypeOf((*MockStore)(nil).InvalidateDocument), arg0, arg1)
}

// ListAccountInfo mocks base method.
func (m *MockStore) ListAccountInfo(arg0 context.Context, arg1 db.ListAccountInfoParams) ([]db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccountInfo", arg0, arg1)
	ret0, _ := ret[0].([]db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAccountInfo indicates an expected call of ListAccountInfo.
func (mr *MockStoreMockRecorder) ListAccountInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccountInfo", reflect.TypeOf((*MockStore)(nil).ListAccountInfo), arg0, arg1)
}

// ListAccounts mocks base method.
func (m *MockStore) ListAccounts(arg0 context.Context, arg1 db.ListAccountsParams) ([]db.Account, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAccounts", arg0, arg1)
	ret0, _ := ret[0].([]db.Account)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListAccounts indicates an expected call of ListAccounts.
func (mr *MockStoreMockRecorder) ListAccounts(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAccounts", reflect.TypeOf((*MockStore)(nil).ListAccounts), arg0, arg1)
}

// ListDocuments mocks base method.
func (m *MockStore) ListDocuments(arg0 context.Context, arg1 db.ListDocumentsParams) ([]db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDocuments", arg0, arg1)
	ret0, _ := ret[0].([]db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDocuments indicates an expected call of ListDocuments.
func (mr *MockStoreMockRecorder) ListDocuments(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDocuments", reflect.TypeOf((*MockStore)(nil).ListDocuments), arg0, arg1)
}

// ListMails mocks base method.
func (m *MockStore) ListMails(arg0 context.Context, arg1 db.ListMailsParams) ([]db.Mail, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMails", arg0, arg1)
	ret0, _ := ret[0].([]db.Mail)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMails indicates an expected call of ListMails.
func (mr *MockStoreMockRecorder) ListMails(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMails", reflect.TypeOf((*MockStore)(nil).ListMails), arg0, arg1)
}

// ListPayments mocks base method.
func (m *MockStore) ListPayments(arg0 context.Context, arg1 uint64) ([]db.Payment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPayments", arg0, arg1)
	ret0, _ := ret[0].([]db.Payment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPayments indicates an expected call of ListPayments.
func (mr *MockStoreMockRecorder) ListPayments(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPayments", reflect.TypeOf((*MockStore)(nil).ListPayments), arg0, arg1)
}

// ListPersons mocks base method.
func (m *MockStore) ListPersons(arg0 context.Context, arg1 uint64) ([]db.Person, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListPersons", arg0, arg1)
	ret0, _ := ret[0].([]db.Person)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListPersons indicates an expected call of ListPersons.
func (mr *MockStoreMockRecorder) ListPersons(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPersons", reflect.TypeOf((*MockStore)(nil).ListPersons), arg0, arg1)
}

// ListProviders mocks base method.
func (m *MockStore) ListProviders(arg0 context.Context, arg1 db.ListProvidersParams) ([]db.Provider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProviders", arg0, arg1)
	ret0, _ := ret[0].([]db.Provider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListProviders indicates an expected call of ListProviders.
func (mr *MockStoreMockRecorder) ListProviders(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProviders", reflect.TypeOf((*MockStore)(nil).ListProviders), arg0, arg1)
}

// ListReturns mocks base method.
func (m *MockStore) ListReturns(arg0 context.Context, arg1 db.ListReturnsParams) ([]db.Return, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReturns", arg0, arg1)
	ret0, _ := ret[0].([]db.Return)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReturns indicates an expected call of ListReturns.
func (mr *MockStoreMockRecorder) ListReturns(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReturns", reflect.TypeOf((*MockStore)(nil).ListReturns), arg0, arg1)
}

// ListReturnsLogs mocks base method.
func (m *MockStore) ListReturnsLogs(arg0 context.Context, arg1 db.ListReturnsLogsParams) ([]db.ReturnsLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReturnsLogs", arg0, arg1)
	ret0, _ := ret[0].([]db.ReturnsLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReturnsLogs indicates an expected call of ListReturnsLogs.
func (mr *MockStoreMockRecorder) ListReturnsLogs(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReturnsLogs", reflect.TypeOf((*MockStore)(nil).ListReturnsLogs), arg0, arg1)
}

// ListReturnsLogsByPersonID mocks base method.
func (m *MockStore) ListReturnsLogsByPersonID(arg0 context.Context, arg1 uint64) ([]db.ReturnsLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListReturnsLogsByPersonID", arg0, arg1)
	ret0, _ := ret[0].([]db.ReturnsLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListReturnsLogsByPersonID indicates an expected call of ListReturnsLogsByPersonID.
func (mr *MockStoreMockRecorder) ListReturnsLogsByPersonID(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListReturnsLogsByPersonID", reflect.TypeOf((*MockStore)(nil).ListReturnsLogsByPersonID), arg0, arg1)
}

// ListSessions mocks base method.
func (m *MockStore) ListSessions(arg0 context.Context, arg1 uint64) ([]db.Session, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListSessions", arg0, arg1)
	ret0, _ := ret[0].([]db.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSessions indicates an expected call of ListSessions.
func (mr *MockStoreMockRecorder) ListSessions(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSessions", reflect.TypeOf((*MockStore)(nil).ListSessions), arg0, arg1)
}

// Query mocks base method.
func (m *MockStore) Query(arg0 context.Context, arg1 string, arg2 ...any) ([]map[string]any, error) {
	m.ctrl.T.Helper()
	varargs := []any{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Query", varargs...)
	ret0, _ := ret[0].([]map[string]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Query indicates an expected call of Query.
func (mr *MockStoreMockRecorder) Query(arg0, arg1 any, arg2 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Query", reflect.TypeOf((*MockStore)(nil).Query), varargs...)
}

// UpdateAccountInfo mocks base method.
func (m *MockStore) UpdateAccountInfo(arg0 context.Context, arg1 db.UpdateAccountInfoParams) (db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountInfo", arg0, arg1)
	ret0, _ := ret[0].(db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAccountInfo indicates an expected call of UpdateAccountInfo.
func (mr *MockStoreMockRecorder) UpdateAccountInfo(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountInfo", reflect.TypeOf((*MockStore)(nil).UpdateAccountInfo), arg0, arg1)
}

// UpdateAccountInfoTx mocks base method.
func (m *MockStore) UpdateAccountInfoTx(arg0 context.Context, arg1 db.UpdateAccountInfoTxParams) (db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountInfoTx", arg0, arg1)
	ret0, _ := ret[0].(db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAccountInfoTx indicates an expected call of UpdateAccountInfoTx.
func (mr *MockStoreMockRecorder) UpdateAccountInfoTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountInfoTx", reflect.TypeOf((*MockStore)(nil).UpdateAccountInfoTx), arg0, arg1)
}

// UpdateAccountPrivacy mocks base method.
func (m *MockStore) UpdateAccountPrivacy(arg0 context.Context, arg1 db.UpdateAccountPrivacyParams) (db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountPrivacy", arg0, arg1)
	ret0, _ := ret[0].(db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAccountPrivacy indicates an expected call of UpdateAccountPrivacy.
func (mr *MockStoreMockRecorder) UpdateAccountPrivacy(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountPrivacy", reflect.TypeOf((*MockStore)(nil).UpdateAccountPrivacy), arg0, arg1)
}

// UpdateAccountPrivacyTx mocks base method.
func (m *MockStore) UpdateAccountPrivacyTx(arg0 context.Context, arg1 db.UpdateAccountPrivacyTxParams) (db.AccountInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAccountPrivacyTx", arg0, arg1)
	ret0, _ := ret[0].(db.AccountInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateAccountPrivacyTx indicates an expected call of UpdateAccountPrivacyTx.
func (mr *MockStoreMockRecorder) UpdateAccountPrivacyTx(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAccountPrivacyTx", reflect.TypeOf((*MockStore)(nil).UpdateAccountPrivacyTx), arg0, arg1)
}

// UpdateDocument mocks base method.
func (m *MockStore) UpdateDocument(arg0 context.Context, arg1 db.UpdateDocumentParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateDocument", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateDocument indicates an expected call of UpdateDocument.
func (mr *MockStoreMockRecorder) UpdateDocument(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDocument", reflect.TypeOf((*MockStore)(nil).UpdateDocument), arg0, arg1)
}

// UpdatePayment mocks base method.
func (m *MockStore) UpdatePayment(arg0 context.Context, arg1 db.UpdatePaymentParams) (db.Payment, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePayment", arg0, arg1)
	ret0, _ := ret[0].(db.Payment)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePayment indicates an expected call of UpdatePayment.
func (mr *MockStoreMockRecorder) UpdatePayment(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePayment", reflect.TypeOf((*MockStore)(nil).UpdatePayment), arg0, arg1)
}

// UpdatePerson mocks base method.
func (m *MockStore) UpdatePerson(arg0 context.Context, arg1 db.UpdatePersonParams) (db.Person, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePerson", arg0, arg1)
	ret0, _ := ret[0].(db.Person)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdatePerson indicates an expected call of UpdatePerson.
func (mr *MockStoreMockRecorder) UpdatePerson(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePerson", reflect.TypeOf((*MockStore)(nil).UpdatePerson), arg0, arg1)
}

// UpdateProvider mocks base method.
func (m *MockStore) UpdateProvider(arg0 context.Context, arg1 db.UpdateProviderParams) (db.Provider, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvider", arg0, arg1)
	ret0, _ := ret[0].(db.Provider)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProvider indicates an expected call of UpdateProvider.
func (mr *MockStoreMockRecorder) UpdateProvider(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvider", reflect.TypeOf((*MockStore)(nil).UpdateProvider), arg0, arg1)
}

// UpdateReturn mocks base method.
func (m *MockStore) UpdateReturn(arg0 context.Context, arg1 db.UpdateReturnParams) (db.Return, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateReturn", arg0, arg1)
	ret0, _ := ret[0].(db.Return)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateReturn indicates an expected call of UpdateReturn.
func (mr *MockStoreMockRecorder) UpdateReturn(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateReturn", reflect.TypeOf((*MockStore)(nil).UpdateReturn), arg0, arg1)
}

// UpdateReturnsLog mocks base method.
func (m *MockStore) UpdateReturnsLog(arg0 context.Context, arg1 db.UpdateReturnsLogParams) (db.ReturnsLog, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateReturnsLog", arg0, arg1)
	ret0, _ := ret[0].(db.ReturnsLog)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateReturnsLog indicates an expected call of UpdateReturnsLog.
func (mr *MockStoreMockRecorder) UpdateReturnsLog(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateReturnsLog", reflect.TypeOf((*MockStore)(nil).UpdateReturnsLog), arg0, arg1)
}

// ValidateDocument mocks base method.
func (m *MockStore) ValidateDocument(arg0 context.Context, arg1 db.ValidateDocumentParams) (db.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateDocument", arg0, arg1)
	ret0, _ := ret[0].(db.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidateDocument indicates an expected call of ValidateDocument.
func (mr *MockStoreMockRecorder) ValidateDocument(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDocument", reflect.TypeOf((*MockStore)(nil).ValidateDocument), arg0, arg1)
}

// VerifyAccountEmail mocks base method.
func (m *MockStore) VerifyAccountEmail(arg0 context.Context, arg1 db.VerifyAccountEmailParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyAccountEmail", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyAccountEmail indicates an expected call of VerifyAccountEmail.
func (mr *MockStoreMockRecorder) VerifyAccountEmail(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyAccountEmail", reflect.TypeOf((*MockStore)(nil).VerifyAccountEmail), arg0, arg1)
}
