// Code generated by MockGen. DO NOT EDIT.
// Source: interface.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	appchain_mgr "github.com/meshplus/bitxhub-core/appchain-mgr"
	syncer "gitlab.33.cn/link33/sidecar/internal/syncer"
	pb "gitlab.33.cn/link33/sidecar/model/pb"
)

// MockSyncer is a mock of Syncer interface.
type MockSyncer struct {
	ctrl     *gomock.Controller
	recorder *MockSyncerMockRecorder
}

// MockSyncerMockRecorder is the mock recorder for MockSyncer.
type MockSyncerMockRecorder struct {
	mock *MockSyncer
}

// NewMockSyncer creates a new mock instance.
func NewMockSyncer(ctrl *gomock.Controller) *MockSyncer {
	mock := &MockSyncer{ctrl: ctrl}
	mock.recorder = &MockSyncerMockRecorder{mock}
	return mock
}

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

// ListenIBTP mocks base method.
func (m *MockSyncer) ListenIBTP() <-chan *pb.IBTPX {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListenIBTP")
	ret0, _ := ret[0].(<-chan *pb.IBTPX)
	return ret0
}

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

// QueryIBTP mocks base method.
func (m *MockSyncer) QueryIBTP(ibtpID string) (*pb.IBTP, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryIBTP", ibtpID)
	ret0, _ := ret[0].(*pb.IBTP)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// QueryIBTP indicates an expected call of QueryIBTP.
func (mr *MockSyncerMockRecorder) QueryIBTP(ibtpID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryIBTP", reflect.TypeOf((*MockSyncer)(nil).QueryIBTP), ibtpID)
}

// QueryInterchainMeta mocks base method.
func (m *MockSyncer) QueryInterchainMeta() *pb.Interchain {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryInterchainMeta")
	ret0, _ := ret[0].(*pb.Interchain)
	return ret0
}

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

// RegisterRollbackHandler mocks base method.
func (m *MockSyncer) RegisterRollbackHandler(handler syncer.RollbackHandler) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterRollbackHandler", handler)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterRollbackHandler indicates an expected call of RegisterRollbackHandler.
func (mr *MockSyncerMockRecorder) RegisterRollbackHandler(handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRollbackHandler", reflect.TypeOf((*MockSyncer)(nil).RegisterRollbackHandler), handler)
}

// SendIBTP mocks base method.
func (m *MockSyncer) SendIBTP(ibtp *pb.IBTP) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendIBTP", ibtp)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendIBTP indicates an expected call of SendIBTP.
func (mr *MockSyncerMockRecorder) SendIBTP(ibtp interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendIBTP", reflect.TypeOf((*MockSyncer)(nil).SendIBTP), ibtp)
}

// MockHandler is a mock of Handler interface.
type MockHandler struct {
	ctrl     *gomock.Controller
	recorder *MockHandlerMockRecorder
}

// MockHandlerMockRecorder is the mock recorder for MockHandler.
type MockHandlerMockRecorder struct {
	mock *MockHandler
}

// NewMockHandler creates a new mock instance.
func NewMockHandler(ctrl *gomock.Controller) *MockHandler {
	mock := &MockHandler{ctrl: ctrl}
	mock.recorder = &MockHandlerMockRecorder{mock}
	return mock
}

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

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

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

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

// GetInterchainById indicates an expected call of GetInterchainById.
func (mr *MockHandlerMockRecorder) GetInterchainById(from interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetInterchainById", reflect.TypeOf((*MockHandler)(nil).GetInterchainById), from)
}

// RegisterAppchainHandler mocks base method.
func (m *MockHandler) RegisterAppchainHandler(handler syncer.AppchainHandler) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterAppchainHandler", handler)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterAppchainHandler indicates an expected call of RegisterAppchainHandler.
func (mr *MockHandlerMockRecorder) RegisterAppchainHandler(handler interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterAppchainHandler", reflect.TypeOf((*MockHandler)(nil).RegisterAppchainHandler), handler)
}

// RegisterRecoverHandler mocks base method.
func (m *MockHandler) RegisterRecoverHandler(arg0 syncer.RecoverUnionHandler) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterRecoverHandler", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterRecoverHandler indicates an expected call of RegisterRecoverHandler.
func (mr *MockHandlerMockRecorder) RegisterRecoverHandler(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterRecoverHandler", reflect.TypeOf((*MockHandler)(nil).RegisterRecoverHandler), arg0)
}