// Code generated by MockGen. DO NOT EDIT.
// Source: notifications.go
//
// Generated by this command:
//
//	mockgen -write_generate_directive -package machine -destination notifications_mock_test.go -source notifications.go
//

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

import (
	reflect "reflect"

	v2 "github.com/cloudevents/sdk-go/v2"
	gomock "go.uber.org/mock/gomock"
)

//go:generate mockgen -write_generate_directive -package machine -destination notifications_mock_test.go -source notifications.go

// MockInfoSource is a mock of InfoSource interface.
type MockInfoSource struct {
	ctrl     *gomock.Controller
	recorder *MockInfoSourceMockRecorder
	isgomock struct{}
}

// MockInfoSourceMockRecorder is the mock recorder for MockInfoSource.
type MockInfoSourceMockRecorder struct {
	mock *MockInfoSource
}

// NewMockInfoSource creates a new mock instance.
func NewMockInfoSource(ctrl *gomock.Controller) *MockInfoSource {
	mock := &MockInfoSource{ctrl: ctrl}
	mock.recorder = &MockInfoSourceMockRecorder{mock}
	return mock
}

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

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

// Identity indicates an expected call of Identity.
func (mr *MockInfoSourceMockRecorder) Identity() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockInfoSource)(nil).Identity))
}

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

// InstanceID indicates an expected call of InstanceID.
func (mr *MockInfoSourceMockRecorder) InstanceID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceID", reflect.TypeOf((*MockInfoSource)(nil).InstanceID))
}

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

// Name indicates an expected call of Name.
func (mr *MockInfoSourceMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockInfoSource)(nil).Name))
}

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

// State indicates an expected call of State.
func (mr *MockInfoSourceMockRecorder) State() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockInfoSource)(nil).State))
}

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

// Version indicates an expected call of Version.
func (mr *MockInfoSourceMockRecorder) Version() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockInfoSource)(nil).Version))
}

// MockWatcherStateNotification is a mock of WatcherStateNotification interface.
type MockWatcherStateNotification struct {
	ctrl     *gomock.Controller
	recorder *MockWatcherStateNotificationMockRecorder
	isgomock struct{}
}

// MockWatcherStateNotificationMockRecorder is the mock recorder for MockWatcherStateNotification.
type MockWatcherStateNotificationMockRecorder struct {
	mock *MockWatcherStateNotification
}

// NewMockWatcherStateNotification creates a new mock instance.
func NewMockWatcherStateNotification(ctrl *gomock.Controller) *MockWatcherStateNotification {
	mock := &MockWatcherStateNotification{ctrl: ctrl}
	mock.recorder = &MockWatcherStateNotificationMockRecorder{mock}
	return mock
}

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

// CloudEvent mocks base method.
func (m *MockWatcherStateNotification) CloudEvent() v2.Event {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloudEvent")
	ret0, _ := ret[0].(v2.Event)
	return ret0
}

// CloudEvent indicates an expected call of CloudEvent.
func (mr *MockWatcherStateNotificationMockRecorder) CloudEvent() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloudEvent", reflect.TypeOf((*MockWatcherStateNotification)(nil).CloudEvent))
}

// JSON mocks base method.
func (m *MockWatcherStateNotification) JSON() ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "JSON")
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// JSON indicates an expected call of JSON.
func (mr *MockWatcherStateNotificationMockRecorder) JSON() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JSON", reflect.TypeOf((*MockWatcherStateNotification)(nil).JSON))
}

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

// SenderID indicates an expected call of SenderID.
func (mr *MockWatcherStateNotificationMockRecorder) SenderID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SenderID", reflect.TypeOf((*MockWatcherStateNotification)(nil).SenderID))
}

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

// String indicates an expected call of String.
func (mr *MockWatcherStateNotificationMockRecorder) String() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockWatcherStateNotification)(nil).String))
}

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

// WatcherType indicates an expected call of WatcherType.
func (mr *MockWatcherStateNotificationMockRecorder) WatcherType() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatcherType", reflect.TypeOf((*MockWatcherStateNotification)(nil).WatcherType))
}

// MockNotificationService is a mock of NotificationService interface.
type MockNotificationService struct {
	ctrl     *gomock.Controller
	recorder *MockNotificationServiceMockRecorder
	isgomock struct{}
}

// MockNotificationServiceMockRecorder is the mock recorder for MockNotificationService.
type MockNotificationServiceMockRecorder struct {
	mock *MockNotificationService
}

// NewMockNotificationService creates a new mock instance.
func NewMockNotificationService(ctrl *gomock.Controller) *MockNotificationService {
	mock := &MockNotificationService{ctrl: ctrl}
	mock.recorder = &MockNotificationServiceMockRecorder{mock}
	return mock
}

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

// Debugf mocks base method.
func (m *MockNotificationService) Debugf(machine InfoSource, watcher, format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{machine, watcher, format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Debugf", varargs...)
}

// Debugf indicates an expected call of Debugf.
func (mr *MockNotificationServiceMockRecorder) Debugf(machine, watcher, format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{machine, watcher, format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Debugf", reflect.TypeOf((*MockNotificationService)(nil).Debugf), varargs...)
}

// Errorf mocks base method.
func (m *MockNotificationService) Errorf(machine InfoSource, watcher, format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{machine, watcher, format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Errorf", varargs...)
}

// Errorf indicates an expected call of Errorf.
func (mr *MockNotificationServiceMockRecorder) Errorf(machine, watcher, format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{machine, watcher, format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Errorf", reflect.TypeOf((*MockNotificationService)(nil).Errorf), varargs...)
}

// Infof mocks base method.
func (m *MockNotificationService) Infof(machine InfoSource, watcher, format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{machine, watcher, format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Infof", varargs...)
}

// Infof indicates an expected call of Infof.
func (mr *MockNotificationServiceMockRecorder) Infof(machine, watcher, format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{machine, watcher, format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Infof", reflect.TypeOf((*MockNotificationService)(nil).Infof), varargs...)
}

// NotifyPostTransition mocks base method.
func (m *MockNotificationService) NotifyPostTransition(t *TransitionNotification) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyPostTransition", t)
	ret0, _ := ret[0].(error)
	return ret0
}

// NotifyPostTransition indicates an expected call of NotifyPostTransition.
func (mr *MockNotificationServiceMockRecorder) NotifyPostTransition(t any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyPostTransition", reflect.TypeOf((*MockNotificationService)(nil).NotifyPostTransition), t)
}

// NotifyWatcherState mocks base method.
func (m *MockNotificationService) NotifyWatcherState(watcher string, state WatcherStateNotification) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NotifyWatcherState", watcher, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// NotifyWatcherState indicates an expected call of NotifyWatcherState.
func (mr *MockNotificationServiceMockRecorder) NotifyWatcherState(watcher, state any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyWatcherState", reflect.TypeOf((*MockNotificationService)(nil).NotifyWatcherState), watcher, state)
}

// Warnf mocks base method.
func (m *MockNotificationService) Warnf(machine InfoSource, watcher, format string, args ...any) {
	m.ctrl.T.Helper()
	varargs := []any{machine, watcher, format}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Warnf", varargs...)
}

// Warnf indicates an expected call of Warnf.
func (mr *MockNotificationServiceMockRecorder) Warnf(machine, watcher, format any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{machine, watcher, format}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Warnf", reflect.TypeOf((*MockNotificationService)(nil).Warnf), varargs...)
}
