// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/tidbcloud/devops/pkg/service/incident (interfaces: IncidentService)
//
// Generated by this command:
//
//	mockgen -destination incident_service_mock.go -package=incident github.com/tidbcloud/devops/pkg/service/incident IncidentService
//

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

import (
	context "context"
	reflect "reflect"

	entity "github.com/tidbcloud/devops/entity"
	gomock "go.uber.org/mock/gomock"
)

// MockIncidentService is a mock of IncidentService interface.
type MockIncidentService struct {
	ctrl     *gomock.Controller
	recorder *MockIncidentServiceMockRecorder
	isgomock struct{}
}

// MockIncidentServiceMockRecorder is the mock recorder for MockIncidentService.
type MockIncidentServiceMockRecorder struct {
	mock *MockIncidentService
}

// NewMockIncidentService creates a new mock instance.
func NewMockIncidentService(ctrl *gomock.Controller) *MockIncidentService {
	mock := &MockIncidentService{ctrl: ctrl}
	mock.recorder = &MockIncidentServiceMockRecorder{mock}
	return mock
}

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

// CompleteFeishuTask mocks base method.
func (m *MockIncidentService) CompleteFeishuTask(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CompleteFeishuTask", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// CompleteFeishuTask indicates an expected call of CompleteFeishuTask.
func (mr *MockIncidentServiceMockRecorder) CompleteFeishuTask(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompleteFeishuTask", reflect.TypeOf((*MockIncidentService)(nil).CompleteFeishuTask), ctx, id)
}

// CreateFeishuTask mocks base method.
func (m *MockIncidentService) CreateFeishuTask(ctx context.Context, task *entity.FeishuTask) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFeishuTask", ctx, task)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFeishuTask indicates an expected call of CreateFeishuTask.
func (mr *MockIncidentServiceMockRecorder) CreateFeishuTask(ctx, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFeishuTask", reflect.TypeOf((*MockIncidentService)(nil).CreateFeishuTask), ctx, task)
}

// CreateIncident mocks base method.
func (m *MockIncidentService) CreateIncident(ctx context.Context, incidentCreation *entity.Incident) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIncident", ctx, incidentCreation)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIncident indicates an expected call of CreateIncident.
func (mr *MockIncidentServiceMockRecorder) CreateIncident(ctx, incidentCreation any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIncident", reflect.TypeOf((*MockIncidentService)(nil).CreateIncident), ctx, incidentCreation)
}

// CreateIncidentLogItem mocks base method.
func (m *MockIncidentService) CreateIncidentLogItem(ctx context.Context, incidentId uint64, logCreation *entity.IncidentLogItem) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIncidentLogItem", ctx, incidentId, logCreation)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIncidentLogItem indicates an expected call of CreateIncidentLogItem.
func (mr *MockIncidentServiceMockRecorder) CreateIncidentLogItem(ctx, incidentId, logCreation any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIncidentLogItem", reflect.TypeOf((*MockIncidentService)(nil).CreateIncidentLogItem), ctx, incidentId, logCreation)
}

// CreateIncidentPostMortem mocks base method.
func (m *MockIncidentService) CreateIncidentPostMortem(ctx context.Context, postMortemCreation *entity.IncidentPostMortem) (*entity.IncidentPostMortem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIncidentPostMortem", ctx, postMortemCreation)
	ret0, _ := ret[0].(*entity.IncidentPostMortem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIncidentPostMortem indicates an expected call of CreateIncidentPostMortem.
func (mr *MockIncidentServiceMockRecorder) CreateIncidentPostMortem(ctx, postMortemCreation any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIncidentPostMortem", reflect.TypeOf((*MockIncidentService)(nil).CreateIncidentPostMortem), ctx, postMortemCreation)
}

// CreateIncidentPostMortemTimelineItem mocks base method.
func (m *MockIncidentService) CreateIncidentPostMortemTimelineItem(ctx context.Context, timelineItemCreation *entity.IncidentPostMortemTimelineItem) (*entity.IncidentPostMortemTimelineItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIncidentPostMortemTimelineItem", ctx, timelineItemCreation)
	ret0, _ := ret[0].(*entity.IncidentPostMortemTimelineItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIncidentPostMortemTimelineItem indicates an expected call of CreateIncidentPostMortemTimelineItem.
func (mr *MockIncidentServiceMockRecorder) CreateIncidentPostMortemTimelineItem(ctx, timelineItemCreation any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIncidentPostMortemTimelineItem", reflect.TypeOf((*MockIncidentService)(nil).CreateIncidentPostMortemTimelineItem), ctx, timelineItemCreation)
}

// CreateIncidentPostMortemToDoActionItem mocks base method.
func (m *MockIncidentService) CreateIncidentPostMortemToDoActionItem(ctx context.Context, actionCreation *CreateIncidentPostMortemActionParams) (*entity.IncidentPostMortemToDoAction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateIncidentPostMortemToDoActionItem", ctx, actionCreation)
	ret0, _ := ret[0].(*entity.IncidentPostMortemToDoAction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateIncidentPostMortemToDoActionItem indicates an expected call of CreateIncidentPostMortemToDoActionItem.
func (mr *MockIncidentServiceMockRecorder) CreateIncidentPostMortemToDoActionItem(ctx, actionCreation any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateIncidentPostMortemToDoActionItem", reflect.TypeOf((*MockIncidentService)(nil).CreateIncidentPostMortemToDoActionItem), ctx, actionCreation)
}

// CreatePostMortemToDoActionsFromFeishuDoc mocks base method.
func (m *MockIncidentService) CreatePostMortemToDoActionsFromFeishuDoc(ctx context.Context, incidentId uint64, feishuURL string) ([]*entity.IncidentPostMortemToDoAction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePostMortemToDoActionsFromFeishuDoc", ctx, incidentId, feishuURL)
	ret0, _ := ret[0].([]*entity.IncidentPostMortemToDoAction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreatePostMortemToDoActionsFromFeishuDoc indicates an expected call of CreatePostMortemToDoActionsFromFeishuDoc.
func (mr *MockIncidentServiceMockRecorder) CreatePostMortemToDoActionsFromFeishuDoc(ctx, incidentId, feishuURL any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePostMortemToDoActionsFromFeishuDoc", reflect.TypeOf((*MockIncidentService)(nil).CreatePostMortemToDoActionsFromFeishuDoc), ctx, incidentId, feishuURL)
}

// DeleteFeishuTask mocks base method.
func (m *MockIncidentService) DeleteFeishuTask(ctx context.Context, id string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFeishuTask", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteFeishuTask indicates an expected call of DeleteFeishuTask.
func (mr *MockIncidentServiceMockRecorder) DeleteFeishuTask(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFeishuTask", reflect.TypeOf((*MockIncidentService)(nil).DeleteFeishuTask), ctx, id)
}

// DeleteIncident mocks base method.
func (m *MockIncidentService) DeleteIncident(ctx context.Context, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIncident", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteIncident indicates an expected call of DeleteIncident.
func (mr *MockIncidentServiceMockRecorder) DeleteIncident(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIncident", reflect.TypeOf((*MockIncidentService)(nil).DeleteIncident), ctx, id)
}

// DeleteIncidentLogItem mocks base method.
func (m *MockIncidentService) DeleteIncidentLogItem(ctx context.Context, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIncidentLogItem", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteIncidentLogItem indicates an expected call of DeleteIncidentLogItem.
func (mr *MockIncidentServiceMockRecorder) DeleteIncidentLogItem(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIncidentLogItem", reflect.TypeOf((*MockIncidentService)(nil).DeleteIncidentLogItem), ctx, id)
}

// DeleteIncidentPostMortem mocks base method.
func (m *MockIncidentService) DeleteIncidentPostMortem(ctx context.Context, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIncidentPostMortem", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteIncidentPostMortem indicates an expected call of DeleteIncidentPostMortem.
func (mr *MockIncidentServiceMockRecorder) DeleteIncidentPostMortem(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIncidentPostMortem", reflect.TypeOf((*MockIncidentService)(nil).DeleteIncidentPostMortem), ctx, id)
}

// DeleteIncidentPostMortemTimelineItem mocks base method.
func (m *MockIncidentService) DeleteIncidentPostMortemTimelineItem(ctx context.Context, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIncidentPostMortemTimelineItem", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteIncidentPostMortemTimelineItem indicates an expected call of DeleteIncidentPostMortemTimelineItem.
func (mr *MockIncidentServiceMockRecorder) DeleteIncidentPostMortemTimelineItem(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIncidentPostMortemTimelineItem", reflect.TypeOf((*MockIncidentService)(nil).DeleteIncidentPostMortemTimelineItem), ctx, id)
}

// DeleteIncidentPostMortemToDoActionItem mocks base method.
func (m *MockIncidentService) DeleteIncidentPostMortemToDoActionItem(ctx context.Context, incidentId uint64, postMortemId *uint64, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteIncidentPostMortemToDoActionItem", ctx, incidentId, postMortemId, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteIncidentPostMortemToDoActionItem indicates an expected call of DeleteIncidentPostMortemToDoActionItem.
func (mr *MockIncidentServiceMockRecorder) DeleteIncidentPostMortemToDoActionItem(ctx, incidentId, postMortemId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteIncidentPostMortemToDoActionItem", reflect.TypeOf((*MockIncidentService)(nil).DeleteIncidentPostMortemToDoActionItem), ctx, incidentId, postMortemId, id)
}

// GenerateReportInFeishuChannel mocks base method.
func (m *MockIncidentService) GenerateReportInFeishuChannel(ctx context.Context, id uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateReportInFeishuChannel", ctx, id)
	ret0, _ := ret[0].(error)
	return ret0
}

// GenerateReportInFeishuChannel indicates an expected call of GenerateReportInFeishuChannel.
func (mr *MockIncidentServiceMockRecorder) GenerateReportInFeishuChannel(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateReportInFeishuChannel", reflect.TypeOf((*MockIncidentService)(nil).GenerateReportInFeishuChannel), ctx, id)
}

// GetIncident mocks base method.
func (m *MockIncidentService) GetIncident(ctx context.Context, id uint64) (*entity.Incident, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIncident", ctx, id)
	ret0, _ := ret[0].(*entity.Incident)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIncident indicates an expected call of GetIncident.
func (mr *MockIncidentServiceMockRecorder) GetIncident(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIncident", reflect.TypeOf((*MockIncidentService)(nil).GetIncident), ctx, id)
}

// GetIncidentLogItem mocks base method.
func (m *MockIncidentService) GetIncidentLogItem(ctx context.Context, logItemId uint64) (*entity.IncidentLogItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIncidentLogItem", ctx, logItemId)
	ret0, _ := ret[0].(*entity.IncidentLogItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIncidentLogItem indicates an expected call of GetIncidentLogItem.
func (mr *MockIncidentServiceMockRecorder) GetIncidentLogItem(ctx, logItemId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIncidentLogItem", reflect.TypeOf((*MockIncidentService)(nil).GetIncidentLogItem), ctx, logItemId)
}

// GetIncidentPostMortem mocks base method.
func (m *MockIncidentService) GetIncidentPostMortem(ctx context.Context, id uint64) (*entity.IncidentPostMortem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIncidentPostMortem", ctx, id)
	ret0, _ := ret[0].(*entity.IncidentPostMortem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIncidentPostMortem indicates an expected call of GetIncidentPostMortem.
func (mr *MockIncidentServiceMockRecorder) GetIncidentPostMortem(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIncidentPostMortem", reflect.TypeOf((*MockIncidentService)(nil).GetIncidentPostMortem), ctx, id)
}

// GetIncidentPostMortemTimelineItem mocks base method.
func (m *MockIncidentService) GetIncidentPostMortemTimelineItem(ctx context.Context, id uint64) (*entity.IncidentPostMortemTimelineItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIncidentPostMortemTimelineItem", ctx, id)
	ret0, _ := ret[0].(*entity.IncidentPostMortemTimelineItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIncidentPostMortemTimelineItem indicates an expected call of GetIncidentPostMortemTimelineItem.
func (mr *MockIncidentServiceMockRecorder) GetIncidentPostMortemTimelineItem(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIncidentPostMortemTimelineItem", reflect.TypeOf((*MockIncidentService)(nil).GetIncidentPostMortemTimelineItem), ctx, id)
}

// GetIncidentPostMortemToDoActionItem mocks base method.
func (m *MockIncidentService) GetIncidentPostMortemToDoActionItem(ctx context.Context, incidentId uint64, postMortemId *uint64, id uint64) (*entity.IncidentPostMortemToDoAction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIncidentPostMortemToDoActionItem", ctx, incidentId, postMortemId, id)
	ret0, _ := ret[0].(*entity.IncidentPostMortemToDoAction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIncidentPostMortemToDoActionItem indicates an expected call of GetIncidentPostMortemToDoActionItem.
func (mr *MockIncidentServiceMockRecorder) GetIncidentPostMortemToDoActionItem(ctx, incidentId, postMortemId, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIncidentPostMortemToDoActionItem", reflect.TypeOf((*MockIncidentService)(nil).GetIncidentPostMortemToDoActionItem), ctx, incidentId, postMortemId, id)
}

// ListIncidentLogs mocks base method.
func (m *MockIncidentService) ListIncidentLogs(ctx context.Context, incidentId uint64) ([]*entity.IncidentLogItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIncidentLogs", ctx, incidentId)
	ret0, _ := ret[0].([]*entity.IncidentLogItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIncidentLogs indicates an expected call of ListIncidentLogs.
func (mr *MockIncidentServiceMockRecorder) ListIncidentLogs(ctx, incidentId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncidentLogs", reflect.TypeOf((*MockIncidentService)(nil).ListIncidentLogs), ctx, incidentId)
}

// ListIncidentPostMortemItems mocks base method.
func (m *MockIncidentService) ListIncidentPostMortemItems(ctx context.Context, incidentId uint64) ([]*entity.IncidentPostMortem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIncidentPostMortemItems", ctx, incidentId)
	ret0, _ := ret[0].([]*entity.IncidentPostMortem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIncidentPostMortemItems indicates an expected call of ListIncidentPostMortemItems.
func (mr *MockIncidentServiceMockRecorder) ListIncidentPostMortemItems(ctx, incidentId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncidentPostMortemItems", reflect.TypeOf((*MockIncidentService)(nil).ListIncidentPostMortemItems), ctx, incidentId)
}

// ListIncidentPostMortemTimelines mocks base method.
func (m *MockIncidentService) ListIncidentPostMortemTimelines(ctx context.Context, postMortemId uint64) ([]*entity.IncidentPostMortemTimelineItem, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIncidentPostMortemTimelines", ctx, postMortemId)
	ret0, _ := ret[0].([]*entity.IncidentPostMortemTimelineItem)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIncidentPostMortemTimelines indicates an expected call of ListIncidentPostMortemTimelines.
func (mr *MockIncidentServiceMockRecorder) ListIncidentPostMortemTimelines(ctx, postMortemId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncidentPostMortemTimelines", reflect.TypeOf((*MockIncidentService)(nil).ListIncidentPostMortemTimelines), ctx, postMortemId)
}

// ListIncidentPostMortemToDoActions mocks base method.
func (m *MockIncidentService) ListIncidentPostMortemToDoActions(ctx context.Context, incidentId uint64, postMortemId *uint64) ([]*entity.IncidentPostMortemToDoAction, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIncidentPostMortemToDoActions", ctx, incidentId, postMortemId)
	ret0, _ := ret[0].([]*entity.IncidentPostMortemToDoAction)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListIncidentPostMortemToDoActions indicates an expected call of ListIncidentPostMortemToDoActions.
func (mr *MockIncidentServiceMockRecorder) ListIncidentPostMortemToDoActions(ctx, incidentId, postMortemId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncidentPostMortemToDoActions", reflect.TypeOf((*MockIncidentService)(nil).ListIncidentPostMortemToDoActions), ctx, incidentId, postMortemId)
}

// ListIncidents mocks base method.
func (m *MockIncidentService) ListIncidents(ctx context.Context, param ListIncidentsParam) ([]*entity.Incident, int64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIncidents", ctx, param)
	ret0, _ := ret[0].([]*entity.Incident)
	ret1, _ := ret[1].(int64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ListIncidents indicates an expected call of ListIncidents.
func (mr *MockIncidentServiceMockRecorder) ListIncidents(ctx, param any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListIncidents", reflect.TypeOf((*MockIncidentService)(nil).ListIncidents), ctx, param)
}

// SyncToDoActionStatusFromTCOCP mocks base method.
func (m *MockIncidentService) SyncToDoActionStatusFromTCOCP(ctx context.Context, incidentId uint64, postMortemId *uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncToDoActionStatusFromTCOCP", ctx, incidentId, postMortemId)
	ret0, _ := ret[0].(error)
	return ret0
}

// SyncToDoActionStatusFromTCOCP indicates an expected call of SyncToDoActionStatusFromTCOCP.
func (mr *MockIncidentServiceMockRecorder) SyncToDoActionStatusFromTCOCP(ctx, incidentId, postMortemId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncToDoActionStatusFromTCOCP", reflect.TypeOf((*MockIncidentService)(nil).SyncToDoActionStatusFromTCOCP), ctx, incidentId, postMortemId)
}

// UpdateFeishuTask mocks base method.
func (m *MockIncidentService) UpdateFeishuTask(ctx context.Context, id string, task *entity.FeishuTask) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateFeishuTask", ctx, id, task)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateFeishuTask indicates an expected call of UpdateFeishuTask.
func (mr *MockIncidentServiceMockRecorder) UpdateFeishuTask(ctx, id, task any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateFeishuTask", reflect.TypeOf((*MockIncidentService)(nil).UpdateFeishuTask), ctx, id, task)
}

// UpdateIncident mocks base method.
func (m *MockIncidentService) UpdateIncident(ctx context.Context, incidentId uint64, incidentUpdate *entity.Incident) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIncident", ctx, incidentId, incidentUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateIncident indicates an expected call of UpdateIncident.
func (mr *MockIncidentServiceMockRecorder) UpdateIncident(ctx, incidentId, incidentUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIncident", reflect.TypeOf((*MockIncidentService)(nil).UpdateIncident), ctx, incidentId, incidentUpdate)
}

// UpdateIncidentLogItem mocks base method.
func (m *MockIncidentService) UpdateIncidentLogItem(ctx context.Context, logItemId uint64, logUpdate *entity.IncidentLogItem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIncidentLogItem", ctx, logItemId, logUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateIncidentLogItem indicates an expected call of UpdateIncidentLogItem.
func (mr *MockIncidentServiceMockRecorder) UpdateIncidentLogItem(ctx, logItemId, logUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIncidentLogItem", reflect.TypeOf((*MockIncidentService)(nil).UpdateIncidentLogItem), ctx, logItemId, logUpdate)
}

// UpdateIncidentPostMortem mocks base method.
func (m *MockIncidentService) UpdateIncidentPostMortem(ctx context.Context, id uint64, postMortemUpdate *entity.IncidentPostMortem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIncidentPostMortem", ctx, id, postMortemUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateIncidentPostMortem indicates an expected call of UpdateIncidentPostMortem.
func (mr *MockIncidentServiceMockRecorder) UpdateIncidentPostMortem(ctx, id, postMortemUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIncidentPostMortem", reflect.TypeOf((*MockIncidentService)(nil).UpdateIncidentPostMortem), ctx, id, postMortemUpdate)
}

// UpdateIncidentPostMortemTimelineItem mocks base method.
func (m *MockIncidentService) UpdateIncidentPostMortemTimelineItem(ctx context.Context, id uint64, timelineUpdate *entity.IncidentPostMortemTimelineItem) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIncidentPostMortemTimelineItem", ctx, id, timelineUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateIncidentPostMortemTimelineItem indicates an expected call of UpdateIncidentPostMortemTimelineItem.
func (mr *MockIncidentServiceMockRecorder) UpdateIncidentPostMortemTimelineItem(ctx, id, timelineUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIncidentPostMortemTimelineItem", reflect.TypeOf((*MockIncidentService)(nil).UpdateIncidentPostMortemTimelineItem), ctx, id, timelineUpdate)
}

// UpdateIncidentPostMortemToDoActionItem mocks base method.
func (m *MockIncidentService) UpdateIncidentPostMortemToDoActionItem(ctx context.Context, incidentId uint64, postMortemId *uint64, id uint64, actionUpdate *EditIncidentPostMortemToDoActionParams) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateIncidentPostMortemToDoActionItem", ctx, incidentId, postMortemId, id, actionUpdate)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateIncidentPostMortemToDoActionItem indicates an expected call of UpdateIncidentPostMortemToDoActionItem.
func (mr *MockIncidentServiceMockRecorder) UpdateIncidentPostMortemToDoActionItem(ctx, incidentId, postMortemId, id, actionUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIncidentPostMortemToDoActionItem", reflect.TypeOf((*MockIncidentService)(nil).UpdateIncidentPostMortemToDoActionItem), ctx, incidentId, postMortemId, id, actionUpdate)
}

// UpdatePostMortemToDoActionImportStatus mocks base method.
func (m *MockIncidentService) UpdatePostMortemToDoActionImportStatus(ctx context.Context, incidentId uint64, status string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdatePostMortemToDoActionImportStatus", ctx, incidentId, status)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdatePostMortemToDoActionImportStatus indicates an expected call of UpdatePostMortemToDoActionImportStatus.
func (mr *MockIncidentServiceMockRecorder) UpdatePostMortemToDoActionImportStatus(ctx, incidentId, status any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePostMortemToDoActionImportStatus", reflect.TypeOf((*MockIncidentService)(nil).UpdatePostMortemToDoActionImportStatus), ctx, incidentId, status)
}