// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/choria-io/go-choria/aagent/model (interfaces: Watcher,WatcherConstructor,ChoriaProvider,Machine)
//
// Generated by this command:
//
//	mockgen -package model -destination model_mock.go github.com/choria-io/go-choria/aagent/model Watcher,WatcherConstructor,ChoriaProvider,Machine
//

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

import (
	context "context"
	json "encoding/json"
	reflect "reflect"
	sync "sync"
	time "time"

	inter "github.com/choria-io/go-choria/inter"
	lifecycle "github.com/choria-io/go-choria/lifecycle"
	jsm "github.com/nats-io/jsm.go"
	logrus "github.com/sirupsen/logrus"
	gomock "go.uber.org/mock/gomock"
)

// MockWatcher is a mock of Watcher interface.
type MockWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockWatcherMockRecorder
	isgomock struct{}
}

// MockWatcherMockRecorder is the mock recorder for MockWatcher.
type MockWatcherMockRecorder struct {
	mock *MockWatcher
}

// NewMockWatcher creates a new mock instance.
func NewMockWatcher(ctrl *gomock.Controller) *MockWatcher {
	mock := &MockWatcher{ctrl: ctrl}
	mock.recorder = &MockWatcherMockRecorder{mock}
	return mock
}

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

// AnnounceInterval mocks base method.
func (m *MockWatcher) AnnounceInterval() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AnnounceInterval")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

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

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

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

// Delete mocks base method.
func (m *MockWatcher) Delete() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Delete")
}

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

// Name mocks base method.
func (m *MockWatcher) 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 *MockWatcherMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockWatcher)(nil).Name))
}

// NotifyStateChance mocks base method.
func (m *MockWatcher) NotifyStateChance() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyStateChance")
}

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

// Run mocks base method.
func (m *MockWatcher) Run(arg0 context.Context, arg1 *sync.WaitGroup) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Run", arg0, arg1)
}

// Run indicates an expected call of Run.
func (mr *MockWatcherMockRecorder) Run(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockWatcher)(nil).Run), arg0, arg1)
}

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

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

// MockWatcherConstructor is a mock of WatcherConstructor interface.
type MockWatcherConstructor struct {
	ctrl     *gomock.Controller
	recorder *MockWatcherConstructorMockRecorder
	isgomock struct{}
}

// MockWatcherConstructorMockRecorder is the mock recorder for MockWatcherConstructor.
type MockWatcherConstructorMockRecorder struct {
	mock *MockWatcherConstructor
}

// NewMockWatcherConstructor creates a new mock instance.
func NewMockWatcherConstructor(ctrl *gomock.Controller) *MockWatcherConstructor {
	mock := &MockWatcherConstructor{ctrl: ctrl}
	mock.recorder = &MockWatcherConstructorMockRecorder{mock}
	return mock
}

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

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

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

// New mocks base method.
func (m *MockWatcherConstructor) New(machine Machine, name string, states []string, requiredState []ForeignMachineState, failEvent, successEvent, interval string, ai time.Duration, properties map[string]any) (any, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "New", machine, name, states, requiredState, failEvent, successEvent, interval, ai, properties)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// New indicates an expected call of New.
func (mr *MockWatcherConstructorMockRecorder) New(machine, name, states, requiredState, failEvent, successEvent, interval, ai, properties any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "New", reflect.TypeOf((*MockWatcherConstructor)(nil).New), machine, name, states, requiredState, failEvent, successEvent, interval, ai, properties)
}

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

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

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

// UnmarshalNotification indicates an expected call of UnmarshalNotification.
func (mr *MockWatcherConstructorMockRecorder) UnmarshalNotification(n any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmarshalNotification", reflect.TypeOf((*MockWatcherConstructor)(nil).UnmarshalNotification), n)
}

// MockChoriaProvider is a mock of ChoriaProvider interface.
type MockChoriaProvider struct {
	ctrl     *gomock.Controller
	recorder *MockChoriaProviderMockRecorder
	isgomock struct{}
}

// MockChoriaProviderMockRecorder is the mock recorder for MockChoriaProvider.
type MockChoriaProviderMockRecorder struct {
	mock *MockChoriaProvider
}

// NewMockChoriaProvider creates a new mock instance.
func NewMockChoriaProvider(ctrl *gomock.Controller) *MockChoriaProvider {
	mock := &MockChoriaProvider{ctrl: ctrl}
	mock.recorder = &MockChoriaProviderMockRecorder{mock}
	return mock
}

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

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

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

// Facts mocks base method.
func (m *MockChoriaProvider) Facts() json.RawMessage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Facts")
	ret0, _ := ret[0].(json.RawMessage)
	return ret0
}

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

// Identity mocks base method.
func (m *MockChoriaProvider) 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 *MockChoriaProviderMockRecorder) Identity() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockChoriaProvider)(nil).Identity))
}

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

// Logger indicates an expected call of Logger.
func (mr *MockChoriaProviderMockRecorder) Logger(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logger", reflect.TypeOf((*MockChoriaProvider)(nil).Logger), arg0)
}

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

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

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

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

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

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

// PublishRaw mocks base method.
func (m *MockChoriaProvider) PublishRaw(arg0 string, arg1 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PublishRaw", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// PublishRaw indicates an expected call of PublishRaw.
func (mr *MockChoriaProviderMockRecorder) PublishRaw(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishRaw", reflect.TypeOf((*MockChoriaProvider)(nil).PublishRaw), arg0, arg1)
}

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

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

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

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

// MockMachine is a mock of Machine interface.
type MockMachine struct {
	ctrl     *gomock.Controller
	recorder *MockMachineMockRecorder
	isgomock struct{}
}

// MockMachineMockRecorder is the mock recorder for MockMachine.
type MockMachineMockRecorder struct {
	mock *MockMachine
}

// NewMockMachine creates a new mock instance.
func NewMockMachine(ctrl *gomock.Controller) *MockMachine {
	mock := &MockMachine{ctrl: ctrl}
	mock.recorder = &MockMachineMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// DataDelete indicates an expected call of DataDelete.
func (mr *MockMachineMockRecorder) DataDelete(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataDelete", reflect.TypeOf((*MockMachine)(nil).DataDelete), key)
}

// DataGet mocks base method.
func (m *MockMachine) DataGet(key string) (any, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DataGet", key)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// DataGet indicates an expected call of DataGet.
func (mr *MockMachineMockRecorder) DataGet(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataGet", reflect.TypeOf((*MockMachine)(nil).DataGet), key)
}

// DataPut mocks base method.
func (m *MockMachine) DataPut(key string, val any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DataPut", key, val)
	ret0, _ := ret[0].(error)
	return ret0
}

// DataPut indicates an expected call of DataPut.
func (mr *MockMachineMockRecorder) DataPut(key, val any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DataPut", reflect.TypeOf((*MockMachine)(nil).DataPut), key, val)
}

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

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

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

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

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

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

// Facts mocks base method.
func (m *MockMachine) Facts() json.RawMessage {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Facts")
	ret0, _ := ret[0].(json.RawMessage)
	return ret0
}

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

// Identity mocks base method.
func (m *MockMachine) 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 *MockMachineMockRecorder) Identity() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Identity", reflect.TypeOf((*MockMachine)(nil).Identity))
}

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

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

// InstanceID mocks base method.
func (m *MockMachine) 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 *MockMachineMockRecorder) InstanceID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstanceID", reflect.TypeOf((*MockMachine)(nil).InstanceID))
}

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

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

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

// LookupExternalMachineState indicates an expected call of LookupExternalMachineState.
func (mr *MockMachineMockRecorder) LookupExternalMachineState(name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LookupExternalMachineState", reflect.TypeOf((*MockMachine)(nil).LookupExternalMachineState), name)
}

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

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

// Name mocks base method.
func (m *MockMachine) 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 *MockMachineMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockMachine)(nil).Name))
}

// NotifyWatcherState mocks base method.
func (m *MockMachine) NotifyWatcherState(arg0 string, arg1 any) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NotifyWatcherState", arg0, arg1)
}

// NotifyWatcherState indicates an expected call of NotifyWatcherState.
func (mr *MockMachineMockRecorder) NotifyWatcherState(arg0, arg1 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotifyWatcherState", reflect.TypeOf((*MockMachine)(nil).NotifyWatcherState), arg0, arg1)
}

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

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

// PublishLifecycleEvent mocks base method.
func (m *MockMachine) PublishLifecycleEvent(t lifecycle.Type, opts ...lifecycle.Option) {
	m.ctrl.T.Helper()
	varargs := []any{t}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "PublishLifecycleEvent", varargs...)
}

// PublishLifecycleEvent indicates an expected call of PublishLifecycleEvent.
func (mr *MockMachineMockRecorder) PublishLifecycleEvent(t any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{t}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishLifecycleEvent", reflect.TypeOf((*MockMachine)(nil).PublishLifecycleEvent), varargs...)
}

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

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

// State mocks base method.
func (m *MockMachine) 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 *MockMachineMockRecorder) State() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "State", reflect.TypeOf((*MockMachine)(nil).State))
}

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

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

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

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

// Transition mocks base method.
func (m *MockMachine) Transition(t string, args ...any) error {
	m.ctrl.T.Helper()
	varargs := []any{t}
	for _, a := range args {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Transition", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Transition indicates an expected call of Transition.
func (mr *MockMachineMockRecorder) Transition(t any, args ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{t}, args...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Transition", reflect.TypeOf((*MockMachine)(nil).Transition), varargs...)
}

// Version mocks base method.
func (m *MockMachine) 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 *MockMachineMockRecorder) Version() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockMachine)(nil).Version))
}

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

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