naise_pos/db/mock/store.go

// Code generated by MockGen. DO NOT EDIT.
// Source: git.nochill.in/nochill/naice_pos/db/sqlc (interfaces: Store)

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

import (
	context "context"
	reflect "reflect"

	db "git.nochill.in/nochill/naice_pos/db/sqlc"
	gomock "github.com/golang/mock/gomock"
	uuid "github.com/google/uuid"
)

// 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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