// Code generated by MockGen. DO NOT EDIT.
// Source: kpt-pasture/module/backend (interfaces: KptService)

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

import (
	context "context"
	model "kpt-pasture/model"
	reflect "reflect"

	cowPb "gitee.com/xuyiping_admin/go_proto/proto/go/backend/cow"
	gomock "github.com/golang/mock/gomock"
)

// MockKptService is a mock of KptService interface.
type MockKptService struct {
	ctrl     *gomock.Controller
	recorder *MockKptServiceMockRecorder
}

// MockKptServiceMockRecorder is the mock recorder for MockKptService.
type MockKptServiceMockRecorder struct {
	mock *MockKptService
}

// NewMockKptService creates a new mock instance.
func NewMockKptService(ctrl *gomock.Controller) *MockKptService {
	mock := &MockKptService{ctrl: ctrl}
	mock.recorder = &MockKptServiceMockRecorder{mock}
	return mock
}

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

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

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

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

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

// AbortionList mocks base method.
func (m *MockKptService) AbortionList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.EventAbortionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AbortionList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.EventAbortionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// BehaviorCurve mocks base method.
func (m *MockKptService) BehaviorCurve(arg0 context.Context, arg1 *cowPb.CowBehaviorCurveRequest) (*model.CowBehaviorCurveResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BehaviorCurve", arg0, arg1)
	ret0, _ := ret[0].(*model.CowBehaviorCurveResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BodyScoreList mocks base method.
func (m *MockKptService) BodyScoreList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBodyScoreEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BodyScoreList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBodyScoreEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// CalendarTableDetail mocks base method.
func (m *MockKptService) CalendarTableDetail(arg0 context.Context, arg1 *cowPb.CalendarTableRequest, arg2 *cowPb.PaginationModel) (interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalendarTableDetail", arg0, arg1, arg2)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CalendarToDoList mocks base method.
func (m *MockKptService) CalendarToDoList(arg0 context.Context, arg1 *cowPb.CalendarToDoRequest, arg2 *cowPb.PaginationModel) (*cowPb.CalendarToDoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalendarToDoList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.CalendarToDoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CalvingCowList mocks base method.
func (m *MockKptService) CalvingCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.CalvingItemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalvingCowList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.CalvingItemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CalvingList mocks base method.
func (m *MockKptService) CalvingList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchLavingEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CalvingList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchLavingEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CowDiseaseCreate mocks base method.
func (m *MockKptService) CowDiseaseCreate(arg0 context.Context, arg1 *cowPb.EventCowDiseaseRequest, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CowDiseaseCreate", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// CowDiseaseList mocks base method.
func (m *MockKptService) CowDiseaseList(arg0 context.Context, arg1 *cowPb.SearchEventCowTreatmentRequest, arg2 *cowPb.PaginationModel) (*cowPb.EventCowDiseaseResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CowDiseaseList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.EventCowDiseaseResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CowDiseaseTreatmentDetail mocks base method.
func (m *MockKptService) CowDiseaseTreatmentDetail(arg0 context.Context, arg1 *cowPb.EventCowTreatmentDetailRequest, arg2 *cowPb.PaginationModel) (*cowPb.EventCowTreatmentDetailResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CowDiseaseTreatmentDetail", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.EventCowTreatmentDetailResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DrugsList mocks base method.
func (m *MockKptService) DrugsList(arg0 context.Context, arg1 *cowPb.SearchDrugsRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchDrugsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DrugsList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchDrugsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EnterList mocks base method.
func (m *MockKptService) EnterList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchEnterEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnterList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchEnterEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// EstrusList mocks base method.
func (m *MockKptService) EstrusList(arg0 context.Context, arg1 *cowPb.EstrusItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.EstrusItemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EstrusList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.EstrusItemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// EventList mocks base method.
func (m *MockKptService) EventList(arg0 context.Context, arg1 *cowPb.SearchCowEventListRequest, arg2 *cowPb.PaginationModel) (*cowPb.CowEventListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EventList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.CowEventListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// FrozenSemenList mocks base method.
func (m *MockKptService) FrozenSemenList(arg0 context.Context, arg1 *cowPb.FrozenSemenRequest, arg2 *cowPb.PaginationModel) (*cowPb.FrozenSemenResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FrozenSemenList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.FrozenSemenResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// GroupTransferList mocks base method.
func (m *MockKptService) GroupTransferList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchTransferGroupEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GroupTransferList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchTransferGroupEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ImmunisationCowList mocks base method.
func (m *MockKptService) ImmunisationCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.ImmunizationItemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImmunisationCowList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.ImmunizationItemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ImmunizationList mocks base method.
func (m *MockKptService) ImmunizationList(arg0 context.Context, arg1 *cowPb.ImmunizationRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchImmunizationResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ImmunizationList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchImmunizationResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IndicatorsComparison mocks base method.
func (m *MockKptService) IndicatorsComparison(arg0 context.Context, arg1 *cowPb.IndicatorsComparisonRequest) (*model.IndicatorsComparisonResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IndicatorsComparison", arg0, arg1)
	ret0, _ := ret[0].(*model.IndicatorsComparisonResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// List mocks base method.
func (m *MockKptService) List(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchCowListResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "List", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchCowListResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MatingCowList mocks base method.
func (m *MockKptService) MatingCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.MatingItemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatingCowList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.MatingItemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MatingList mocks base method.
func (m *MockKptService) MatingList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.MatingEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatingList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.MatingEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MatingTimely mocks base method.
func (m *MockKptService) MatingTimely(arg0 context.Context, arg1 *cowPb.MatingTimelyRequest) (*model.MatingTimelyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatingTimely", arg0, arg1)
	ret0, _ := ret[0].(*model.MatingTimelyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MedicalEquipmentList mocks base method.
func (m *MockKptService) MedicalEquipmentList(arg0 context.Context, arg1 *cowPb.SearchMedicalEquipmentRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchMedicalEquipmentResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MedicalEquipmentList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchMedicalEquipmentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MultipleFactorAnalysis mocks base method.
func (m *MockKptService) MultipleFactorAnalysis(arg0 context.Context, arg1 *cowPb.MultiFactorPregnancyRateRequest) (*model.MultiFactorPregnancyRateResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MultipleFactorAnalysis", arg0, arg1)
	ret0, _ := ret[0].(*model.MultiFactorPregnancyRateResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NeckRingList mocks base method.
func (m *MockKptService) NeckRingList(arg0 context.Context, arg1 *cowPb.SearchNeckRingRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchNeckRingResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NeckRingList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchNeckRingResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// OrderList mocks base method.
func (m *MockKptService) OrderList(arg0 context.Context, arg1 *cowPb.SearchWorkOrderRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchWorkOrderResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OrderList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchWorkOrderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

// OutboundList mocks base method.
func (m *MockKptService) OutboundList(arg0 context.Context, arg1 *cowPb.SearchOutboundApplyRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchOutboundApplyResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OutboundList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchOutboundApplyResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PenWeight mocks base method.
func (m *MockKptService) PenWeight(arg0 context.Context, arg1 *cowPb.PenWeightRequest, arg2 *cowPb.PaginationModel) (*cowPb.PenWeightResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PenWeight", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.PenWeightResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PregnancyCheckCowList mocks base method.
func (m *MockKptService) PregnancyCheckCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnancyCheckItemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PregnancyCheckCowList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.PregnancyCheckItemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// PregnancyReport mocks base method.
func (m *MockKptService) PregnancyReport(arg0 context.Context, arg1 *cowPb.PregnancyReportRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnancyReportResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PregnancyReport", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.PregnancyReportResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// PregnantCheckList mocks base method.
func (m *MockKptService) PregnantCheckList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.PregnantCheckEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PregnantCheckList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.PregnantCheckEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// SameTimeCowList mocks base method.
func (m *MockKptService) SameTimeCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.SameTimeItemResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SameTimeCowList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SameTimeItemResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// SameTimeList mocks base method.
func (m *MockKptService) SameTimeList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchSameTimeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SameTimeList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchSameTimeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchBarnList mocks base method.
func (m *MockKptService) SearchBarnList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBarnResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchBarnList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBarnResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchBarnTypeList mocks base method.
func (m *MockKptService) SearchBarnTypeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchBarnTypeList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchBreedStatusList mocks base method.
func (m *MockKptService) SearchBreedStatusList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchBreedStatusList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchCowKindList mocks base method.
func (m *MockKptService) SearchCowKindList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchCowKindList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchCowSourceList mocks base method.
func (m *MockKptService) SearchCowSourceList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchCowSourceList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchCowStatusList mocks base method.
func (m *MockKptService) SearchCowStatusList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchCowStatusList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchCowTypeList mocks base method.
func (m *MockKptService) SearchCowTypeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchCowTypeList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDiseaseList mocks base method.
func (m *MockKptService) SearchDiseaseList(arg0 context.Context, arg1 *cowPb.SearchDiseaseRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchDiseaseResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDiseaseList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchDiseaseResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchDiseaseTypeList mocks base method.
func (m *MockKptService) SearchDiseaseTypeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchDiseaseTypeList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchPrescriptionList mocks base method.
func (m *MockKptService) SearchPrescriptionList(arg0 context.Context, arg1 *cowPb.SearchPrescriptionRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchPrescriptionResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchPrescriptionList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchPrescriptionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchSameTimeList mocks base method.
func (m *MockKptService) SearchSameTimeList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SameTimeResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchSameTimeList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SameTimeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchSystemDeptList mocks base method.
func (m *MockKptService) SearchSystemDeptList(arg0 context.Context, arg1 *cowPb.SearchDeptRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchDeptResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchSystemDeptList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchDeptResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchSystemMenuList mocks base method.
func (m *MockKptService) SearchSystemMenuList(arg0 context.Context, arg1 *cowPb.SearchMenuRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchMenuResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchSystemMenuList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchMenuResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchSystemRoleList mocks base method.
func (m *MockKptService) SearchSystemRoleList(arg0 context.Context, arg1 *cowPb.SearchRoleRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchRoleResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchSystemRoleList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchRoleResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchSystemUserList mocks base method.
func (m *MockKptService) SearchSystemUserList(arg0 context.Context, arg1 *cowPb.SearchUserRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchUserResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchSystemUserList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchUserResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SearchTransferPenReasonList mocks base method.
func (m *MockKptService) SearchTransferPenReasonList(arg0 context.Context, arg1 *cowPb.SearchNameRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchBaseConfigResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SearchTransferPenReasonList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchBaseConfigResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// SubmitEventLog mocks base method.
func (m *MockKptService) SubmitEventLog(arg0 context.Context, arg1 int64, arg2 *model.Cow, arg3 cowPb.EventType_Kind, arg4 cowPb.ExposeEstrusType_Kind, arg5 interface{}) *model.EventCowLog {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SubmitEventLog", arg0, arg1, arg2, arg3, arg4, arg5)
	ret0, _ := ret[0].(*model.EventCowLog)
	return ret0
}

// SubmitEventLog indicates an expected call of SubmitEventLog.
func (mr *MockKptServiceMockRecorder) SubmitEventLog(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitEventLog", reflect.TypeOf((*MockKptService)(nil).SubmitEventLog), arg0, arg1, arg2, arg3, arg4, arg5)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UserWorkOrderList mocks base method.
func (m *MockKptService) UserWorkOrderList(arg0 context.Context, arg1 cowPb.WorkOrderStatus_Kind, arg2 *cowPb.PaginationModel) (*cowPb.UserWorkOrderResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UserWorkOrderList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.UserWorkOrderResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// WeaningCowList mocks base method.
func (m *MockKptService) WeaningCowList(arg0 context.Context, arg1 *cowPb.ItemsRequest, arg2 *cowPb.PaginationModel) (*cowPb.WeaningItemsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WeaningCowList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.WeaningItemsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// WeightList mocks base method.
func (m *MockKptService) WeightList(arg0 context.Context, arg1 *cowPb.SearchEventRequest, arg2 *cowPb.PaginationModel) (*cowPb.SearchWeightEventResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WeightList", arg0, arg1, arg2)
	ret0, _ := ret[0].(*cowPb.SearchWeightEventResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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