// Code generated by MockGen. DO NOT EDIT.
// Source: kpt-tmr-group/module/backend (interfaces: PastureService)

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

import (
	bytes "bytes"
	context "context"
	io "io"
	model "kpt-tmr-group/model"
	operationPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/operation"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockPastureService is a mock of PastureService interface.
type MockPastureService struct {
	ctrl     *gomock.Controller
	recorder *MockPastureServiceMockRecorder
}

// MockPastureServiceMockRecorder is the mock recorder for MockPastureService.
type MockPastureServiceMockRecorder struct {
	mock *MockPastureService
}

// NewMockPastureService creates a new mock instance.
func NewMockPastureService(ctrl *gomock.Controller) *MockPastureService {
	mock := &MockPastureService{ctrl: ctrl}
	mock.recorder = &MockPastureServiceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ExcelExportFeedFormula mocks base method.
func (m *MockPastureService) ExcelExportFeedFormula(arg0 context.Context, arg1 *operationPb.SearchFeedFormulaRequest) (*bytes.Buffer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExcelExportFeedFormula", arg0, arg1)
	ret0, _ := ret[0].(*bytes.Buffer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ExcelExportForage mocks base method.
func (m *MockPastureService) ExcelExportForage(arg0 context.Context, arg1 *operationPb.SearchForageListRequest) (*bytes.Buffer, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExcelExportForage", arg0, arg1)
	ret0, _ := ret[0].(*bytes.Buffer)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ForageEnumList mocks base method.
func (m *MockPastureService) ForageEnumList(arg0 context.Context) *operationPb.ForageEnumListResponse {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForageEnumList", arg0)
	ret0, _ := ret[0].(*operationPb.ForageEnumListResponse)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SmallMaterial mocks base method.
func (m *MockPastureService) SmallMaterial(arg0 context.Context, arg1 *operationPb.SmallMaterialRequest) (*model.PastureCommonResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SmallMaterial", arg0, arg1)
	ret0, _ := ret[0].(*model.PastureCommonResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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