// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/uber/cadence/tools/cli (interfaces: ManagerFactory)
//
// Generated by this command:
//
//	mockgen -package cli -destination mock_manager_factory.go -self_package github.com/uber/cadence/tools/cli github.com/uber/cadence/tools/cli ManagerFactory
//

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

import (
	reflect "reflect"

	cli "github.com/urfave/cli/v2"
	gomock "go.uber.org/mock/gomock"

	persistence "github.com/uber/cadence/common/persistence"
	client "github.com/uber/cadence/common/persistence/client"
	invariant "github.com/uber/cadence/common/reconciliation/invariant"
)

// MockManagerFactory is a mock of ManagerFactory interface.
type MockManagerFactory struct {
	ctrl     *gomock.Controller
	recorder *MockManagerFactoryMockRecorder
	isgomock struct{}
}

// MockManagerFactoryMockRecorder is the mock recorder for MockManagerFactory.
type MockManagerFactoryMockRecorder struct {
	mock *MockManagerFactory
}

// NewMockManagerFactory creates a new mock instance.
func NewMockManagerFactory(ctrl *gomock.Controller) *MockManagerFactory {
	mock := &MockManagerFactory{ctrl: ctrl}
	mock.recorder = &MockManagerFactoryMockRecorder{mock}
	return mock
}

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

// initPersistenceFactory mocks base method.
func (m *MockManagerFactory) initPersistenceFactory(c *cli.Context) (client.Factory, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "initPersistenceFactory", c)
	ret0, _ := ret[0].(client.Factory)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// initPersistenceFactory indicates an expected call of initPersistenceFactory.
func (mr *MockManagerFactoryMockRecorder) initPersistenceFactory(c any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "initPersistenceFactory", reflect.TypeOf((*MockManagerFactory)(nil).initPersistenceFactory), c)
}

// initializeDomainManager mocks base method.
func (m *MockManagerFactory) initializeDomainManager(c *cli.Context) (persistence.DomainManager, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "initializeDomainManager", c)
	ret0, _ := ret[0].(persistence.DomainManager)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// initializeDomainManager indicates an expected call of initializeDomainManager.
func (mr *MockManagerFactoryMockRecorder) initializeDomainManager(c any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "initializeDomainManager", reflect.TypeOf((*MockManagerFactory)(nil).initializeDomainManager), c)
}

// initializeExecutionManager mocks base method.
func (m *MockManagerFactory) initializeExecutionManager(c *cli.Context, shardID int) (persistence.ExecutionManager, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "initializeExecutionManager", c, shardID)
	ret0, _ := ret[0].(persistence.ExecutionManager)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// initializeExecutionManager indicates an expected call of initializeExecutionManager.
func (mr *MockManagerFactoryMockRecorder) initializeExecutionManager(c, shardID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "initializeExecutionManager", reflect.TypeOf((*MockManagerFactory)(nil).initializeExecutionManager), c, shardID)
}

// initializeHistoryManager mocks base method.
func (m *MockManagerFactory) initializeHistoryManager(c *cli.Context) (persistence.HistoryManager, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "initializeHistoryManager", c)
	ret0, _ := ret[0].(persistence.HistoryManager)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// initializeHistoryManager indicates an expected call of initializeHistoryManager.
func (mr *MockManagerFactoryMockRecorder) initializeHistoryManager(c any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "initializeHistoryManager", reflect.TypeOf((*MockManagerFactory)(nil).initializeHistoryManager), c)
}

// initializeInvariantManager mocks base method.
func (m *MockManagerFactory) initializeInvariantManager(ivs []invariant.Invariant) (invariant.Manager, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "initializeInvariantManager", ivs)
	ret0, _ := ret[0].(invariant.Manager)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// initializeInvariantManager indicates an expected call of initializeInvariantManager.
func (mr *MockManagerFactoryMockRecorder) initializeInvariantManager(ivs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "initializeInvariantManager", reflect.TypeOf((*MockManagerFactory)(nil).initializeInvariantManager), ivs)
}

// initializeShardManager mocks base method.
func (m *MockManagerFactory) initializeShardManager(c *cli.Context) (persistence.ShardManager, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "initializeShardManager", c)
	ret0, _ := ret[0].(persistence.ShardManager)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// initializeShardManager indicates an expected call of initializeShardManager.
func (mr *MockManagerFactoryMockRecorder) initializeShardManager(c any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "initializeShardManager", reflect.TypeOf((*MockManagerFactory)(nil).initializeShardManager), c)
}
