// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/tidbcloud/devops/pkg/infra/clients/larkcli/notify (interfaces: Notification)
//
// Generated by this command:
//
//	mockgen -destination notification_mock.go -package=notify github.com/tidbcloud/devops/pkg/infra/clients/larkcli/notify Notification
//

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

import (
	context "context"
	reflect "reflect"

	larkim "github.com/larksuite/oapi-sdk-go/v3/service/im/v1"
	gomock "go.uber.org/mock/gomock"
)

// MockNotification is a mock of Notification interface.
type MockNotification struct {
	ctrl     *gomock.Controller
	recorder *MockNotificationMockRecorder
	isgomock struct{}
}

// MockNotificationMockRecorder is the mock recorder for MockNotification.
type MockNotificationMockRecorder struct {
	mock *MockNotification
}

// NewMockNotification creates a new mock instance.
func NewMockNotification(ctrl *gomock.Controller) *MockNotification {
	mock := &MockNotification{ctrl: ctrl}
	mock.recorder = &MockNotificationMockRecorder{mock}
	return mock
}

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

// ApprovalCC mocks base method.
func (m *MockNotification) ApprovalCC(ctx context.Context, userID string, param ApprovalCCParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApprovalCC", ctx, userID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ApprovalEnd mocks base method.
func (m *MockNotification) ApprovalEnd(ctx context.Context, userID string, param ApprovalEndParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApprovalEnd", ctx, userID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ApprovalStart mocks base method.
func (m *MockNotification) ApprovalStart(ctx context.Context, userID string, param ApprovalStartParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApprovalStart", ctx, userID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ApprovalTaskStart mocks base method.
func (m *MockNotification) ApprovalTaskStart(ctx context.Context, userID string, param ApprovalTaskStartParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApprovalTaskStart", ctx, userID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenerateChatShareLink mocks base method.
func (m *MockNotification) GenerateChatShareLink(ctx context.Context, chatID, validityPeriod string) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateChatShareLink", ctx, chatID, validityPeriod)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateChatShareLink indicates an expected call of GenerateChatShareLink.
func (mr *MockNotificationMockRecorder) GenerateChatShareLink(ctx, chatID, validityPeriod any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateChatShareLink", reflect.TypeOf((*MockNotification)(nil).GenerateChatShareLink), ctx, chatID, validityPeriod)
}

// GetTopicReplies mocks base method.
func (m *MockNotification) GetTopicReplies(ctx context.Context, chatID, topicID, startTime, endTime string) ([]*larkim.Message, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetTopicReplies", ctx, chatID, topicID, startTime, endTime)
	ret0, _ := ret[0].([]*larkim.Message)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetTopicReplies indicates an expected call of GetTopicReplies.
func (mr *MockNotificationMockRecorder) GetTopicReplies(ctx, chatID, topicID, startTime, endTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTopicReplies", reflect.TypeOf((*MockNotification)(nil).GetTopicReplies), ctx, chatID, topicID, startTime, endTime)
}

// IncidentToDoActionOverdue mocks base method.
func (m *MockNotification) IncidentToDoActionOverdue(ctx context.Context, email string, param IncidentToDoActionOverdueParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncidentToDoActionOverdue", ctx, email, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IncidentToDoActionOverdueSummary mocks base method.
func (m *MockNotification) IncidentToDoActionOverdueSummary(ctx context.Context, email string, param IncidentToDoActionOverdueSummaryParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncidentToDoActionOverdueSummary", ctx, email, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IncidentToDoActionTCOCPCreated mocks base method.
func (m *MockNotification) IncidentToDoActionTCOCPCreated(ctx context.Context, email string, param IncidentToDoActionTCOCPCreatedParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncidentToDoActionTCOCPCreated", ctx, email, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// IncidentTopic mocks base method.
func (m *MockNotification) IncidentTopic(ctx context.Context, chatID string, param IncidentTopicParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IncidentTopic", ctx, chatID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListMessages mocks base method.
func (m *MockNotification) ListMessages(ctx context.Context, chatID, startTime, endTime string) (*larkim.ListMessageRespData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListMessages", ctx, chatID, startTime, endTime)
	ret0, _ := ret[0].(*larkim.ListMessageRespData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListMessages indicates an expected call of ListMessages.
func (mr *MockNotificationMockRecorder) ListMessages(ctx, chatID, startTime, endTime any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListMessages", reflect.TypeOf((*MockNotification)(nil).ListMessages), ctx, chatID, startTime, endTime)
}

// MaintenanceTaskClosed mocks base method.
func (m *MockNotification) MaintenanceTaskClosed(ctx context.Context, chatID string, param MaintenanceTaskClosedParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaintenanceTaskClosed", ctx, chatID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MaintenanceTaskRunning mocks base method.
func (m *MockNotification) MaintenanceTaskRunning(ctx context.Context, chatID string, param MaintenanceTaskRunningParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MaintenanceTaskRunning", ctx, chatID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NotifyJiraIssueForS1Ticket mocks base method.
func (m *MockNotification) NotifyJiraIssueForS1Ticket(ctx context.Context, chatID string, param JiraIssueInformationForS1TicketsParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyJiraIssueForS1Ticket", ctx, chatID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NotifyLongTailAlert mocks base method.
func (m *MockNotification) NotifyLongTailAlert(ctx context.Context, userID string, param NotifyAlertParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyLongTailAlert", ctx, userID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NotifyLongTailTicketsUnify mocks base method.
func (m *MockNotification) NotifyLongTailTicketsUnify(ctx context.Context, userID string, param NotifyLongTailTicketsUnifyParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyLongTailTicketsUnify", ctx, userID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ReleaseClose mocks base method.
func (m *MockNotification) ReleaseClose(ctx context.Context, msgID string, param ReleaseCloseParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseClose", ctx, msgID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReleaseDeployment mocks base method.
func (m *MockNotification) ReleaseDeployment(ctx context.Context, msgID string, param ReleaseDeploymentParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseDeployment", ctx, msgID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReleaseTopic mocks base method.
func (m *MockNotification) ReleaseTopic(ctx context.Context, chatID string, param ReleaseTopicParam) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseTopic", ctx, chatID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplyMessage mocks base method.
func (m *MockNotification) ReplyMessage(ctx context.Context, msgID string, param Param, replyInThread bool) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplyMessage", ctx, msgID, param, replyInThread)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplyMessage indicates an expected call of ReplyMessage.
func (mr *MockNotificationMockRecorder) ReplyMessage(ctx, msgID, param, replyInThread any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplyMessage", reflect.TypeOf((*MockNotification)(nil).ReplyMessage), ctx, msgID, param, replyInThread)
}

// SendMessage mocks base method.
func (m *MockNotification) SendMessage(ctx context.Context, receiveType, receiveID string, param Param) (*string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendMessage", ctx, receiveType, receiveID, param)
	ret0, _ := ret[0].(*string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SendMessage indicates an expected call of SendMessage.
func (mr *MockNotificationMockRecorder) SendMessage(ctx, receiveType, receiveID, param any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendMessage", reflect.TypeOf((*MockNotification)(nil).SendMessage), ctx, receiveType, receiveID, param)
}

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

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