// Code generated by MockGen. DO NOT EDIT.
// Source: grogu/submitter/expected_types.go
//
// Generated by this command:
//
//	mockgen -source=grogu/submitter/expected_types.go -package testutil -destination grogu/submitter/testutil/expected_types_mock.go
//

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

import (
	context "context"
	reflect "reflect"

	proto "github.com/bandprotocol/bothan/bothan-api/client/go-client/proto/bothan/v1"
	bytes "github.com/cometbft/cometbft/libs/bytes"
	log "github.com/cometbft/cometbft/libs/log"
	client "github.com/cometbft/cometbft/rpc/client"
	coretypes "github.com/cometbft/cometbft/rpc/core/types"
	types "github.com/cometbft/cometbft/types"
	types0 "github.com/cosmos/cosmos-sdk/types"
	types1 "github.com/cosmos/cosmos-sdk/x/auth/types"
	gomock "go.uber.org/mock/gomock"
)

// MockRemoteClient is a mock of RemoteClient interface.
type MockRemoteClient struct {
	ctrl     *gomock.Controller
	recorder *MockRemoteClientMockRecorder
	isgomock struct{}
}

// MockRemoteClientMockRecorder is the mock recorder for MockRemoteClient.
type MockRemoteClientMockRecorder struct {
	mock *MockRemoteClient
}

// NewMockRemoteClient creates a new mock instance.
func NewMockRemoteClient(ctrl *gomock.Controller) *MockRemoteClient {
	mock := &MockRemoteClient{ctrl: ctrl}
	mock.recorder = &MockRemoteClientMockRecorder{mock}
	return mock
}

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

// ABCIInfo mocks base method.
func (m *MockRemoteClient) ABCIInfo(arg0 context.Context) (*coretypes.ResultABCIInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ABCIInfo", arg0)
	ret0, _ := ret[0].(*coretypes.ResultABCIInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ABCIQuery mocks base method.
func (m *MockRemoteClient) ABCIQuery(ctx context.Context, path string, data bytes.HexBytes) (*coretypes.ResultABCIQuery, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ABCIQuery", ctx, path, data)
	ret0, _ := ret[0].(*coretypes.ResultABCIQuery)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ABCIQuery indicates an expected call of ABCIQuery.
func (mr *MockRemoteClientMockRecorder) ABCIQuery(ctx, path, data any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQuery", reflect.TypeOf((*MockRemoteClient)(nil).ABCIQuery), ctx, path, data)
}

// ABCIQueryWithOptions mocks base method.
func (m *MockRemoteClient) ABCIQueryWithOptions(ctx context.Context, path string, data bytes.HexBytes, opts client.ABCIQueryOptions) (*coretypes.ResultABCIQuery, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ABCIQueryWithOptions", ctx, path, data, opts)
	ret0, _ := ret[0].(*coretypes.ResultABCIQuery)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ABCIQueryWithOptions indicates an expected call of ABCIQueryWithOptions.
func (mr *MockRemoteClientMockRecorder) ABCIQueryWithOptions(ctx, path, data, opts any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ABCIQueryWithOptions", reflect.TypeOf((*MockRemoteClient)(nil).ABCIQueryWithOptions), ctx, path, data, opts)
}

// Block mocks base method.
func (m *MockRemoteClient) Block(ctx context.Context, height *int64) (*coretypes.ResultBlock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Block", ctx, height)
	ret0, _ := ret[0].(*coretypes.ResultBlock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Block indicates an expected call of Block.
func (mr *MockRemoteClientMockRecorder) Block(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Block", reflect.TypeOf((*MockRemoteClient)(nil).Block), ctx, height)
}

// BlockByHash mocks base method.
func (m *MockRemoteClient) BlockByHash(ctx context.Context, hash []byte) (*coretypes.ResultBlock, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockByHash", ctx, hash)
	ret0, _ := ret[0].(*coretypes.ResultBlock)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlockByHash indicates an expected call of BlockByHash.
func (mr *MockRemoteClientMockRecorder) BlockByHash(ctx, hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockByHash", reflect.TypeOf((*MockRemoteClient)(nil).BlockByHash), ctx, hash)
}

// BlockResults mocks base method.
func (m *MockRemoteClient) BlockResults(ctx context.Context, height *int64) (*coretypes.ResultBlockResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockResults", ctx, height)
	ret0, _ := ret[0].(*coretypes.ResultBlockResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlockResults indicates an expected call of BlockResults.
func (mr *MockRemoteClientMockRecorder) BlockResults(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockResults", reflect.TypeOf((*MockRemoteClient)(nil).BlockResults), ctx, height)
}

// BlockSearch mocks base method.
func (m *MockRemoteClient) BlockSearch(ctx context.Context, query string, page, perPage *int, orderBy string) (*coretypes.ResultBlockSearch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockSearch", ctx, query, page, perPage, orderBy)
	ret0, _ := ret[0].(*coretypes.ResultBlockSearch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlockSearch indicates an expected call of BlockSearch.
func (mr *MockRemoteClientMockRecorder) BlockSearch(ctx, query, page, perPage, orderBy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockSearch", reflect.TypeOf((*MockRemoteClient)(nil).BlockSearch), ctx, query, page, perPage, orderBy)
}

// BlockchainInfo mocks base method.
func (m *MockRemoteClient) BlockchainInfo(ctx context.Context, minHeight, maxHeight int64) (*coretypes.ResultBlockchainInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockchainInfo", ctx, minHeight, maxHeight)
	ret0, _ := ret[0].(*coretypes.ResultBlockchainInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlockchainInfo indicates an expected call of BlockchainInfo.
func (mr *MockRemoteClientMockRecorder) BlockchainInfo(ctx, minHeight, maxHeight any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockchainInfo", reflect.TypeOf((*MockRemoteClient)(nil).BlockchainInfo), ctx, minHeight, maxHeight)
}

// BroadcastEvidence mocks base method.
func (m *MockRemoteClient) BroadcastEvidence(arg0 context.Context, arg1 types.Evidence) (*coretypes.ResultBroadcastEvidence, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BroadcastEvidence", arg0, arg1)
	ret0, _ := ret[0].(*coretypes.ResultBroadcastEvidence)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BroadcastTxAsync mocks base method.
func (m *MockRemoteClient) BroadcastTxAsync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BroadcastTxAsync", arg0, arg1)
	ret0, _ := ret[0].(*coretypes.ResultBroadcastTx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BroadcastTxCommit mocks base method.
func (m *MockRemoteClient) BroadcastTxCommit(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTxCommit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BroadcastTxCommit", arg0, arg1)
	ret0, _ := ret[0].(*coretypes.ResultBroadcastTxCommit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BroadcastTxSync mocks base method.
func (m *MockRemoteClient) BroadcastTxSync(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultBroadcastTx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BroadcastTxSync", arg0, arg1)
	ret0, _ := ret[0].(*coretypes.ResultBroadcastTx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckTx mocks base method.
func (m *MockRemoteClient) CheckTx(arg0 context.Context, arg1 types.Tx) (*coretypes.ResultCheckTx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckTx", arg0, arg1)
	ret0, _ := ret[0].(*coretypes.ResultCheckTx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Commit mocks base method.
func (m *MockRemoteClient) Commit(ctx context.Context, height *int64) (*coretypes.ResultCommit, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", ctx, height)
	ret0, _ := ret[0].(*coretypes.ResultCommit)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Commit indicates an expected call of Commit.
func (mr *MockRemoteClientMockRecorder) Commit(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockRemoteClient)(nil).Commit), ctx, height)
}

// ConsensusParams mocks base method.
func (m *MockRemoteClient) ConsensusParams(ctx context.Context, height *int64) (*coretypes.ResultConsensusParams, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConsensusParams", ctx, height)
	ret0, _ := ret[0].(*coretypes.ResultConsensusParams)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ConsensusParams indicates an expected call of ConsensusParams.
func (mr *MockRemoteClientMockRecorder) ConsensusParams(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsensusParams", reflect.TypeOf((*MockRemoteClient)(nil).ConsensusParams), ctx, height)
}

// ConsensusState mocks base method.
func (m *MockRemoteClient) ConsensusState(arg0 context.Context) (*coretypes.ResultConsensusState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConsensusState", arg0)
	ret0, _ := ret[0].(*coretypes.ResultConsensusState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DumpConsensusState mocks base method.
func (m *MockRemoteClient) DumpConsensusState(arg0 context.Context) (*coretypes.ResultDumpConsensusState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DumpConsensusState", arg0)
	ret0, _ := ret[0].(*coretypes.ResultDumpConsensusState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Genesis mocks base method.
func (m *MockRemoteClient) Genesis(arg0 context.Context) (*coretypes.ResultGenesis, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Genesis", arg0)
	ret0, _ := ret[0].(*coretypes.ResultGenesis)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GenesisChunked mocks base method.
func (m *MockRemoteClient) GenesisChunked(arg0 context.Context, arg1 uint) (*coretypes.ResultGenesisChunk, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenesisChunked", arg0, arg1)
	ret0, _ := ret[0].(*coretypes.ResultGenesisChunk)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Header mocks base method.
func (m *MockRemoteClient) Header(ctx context.Context, height *int64) (*coretypes.ResultHeader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Header", ctx, height)
	ret0, _ := ret[0].(*coretypes.ResultHeader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Header indicates an expected call of Header.
func (mr *MockRemoteClientMockRecorder) Header(ctx, height any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Header", reflect.TypeOf((*MockRemoteClient)(nil).Header), ctx, height)
}

// HeaderByHash mocks base method.
func (m *MockRemoteClient) HeaderByHash(ctx context.Context, hash bytes.HexBytes) (*coretypes.ResultHeader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HeaderByHash", ctx, hash)
	ret0, _ := ret[0].(*coretypes.ResultHeader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HeaderByHash indicates an expected call of HeaderByHash.
func (mr *MockRemoteClientMockRecorder) HeaderByHash(ctx, hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeaderByHash", reflect.TypeOf((*MockRemoteClient)(nil).HeaderByHash), ctx, hash)
}

// Health mocks base method.
func (m *MockRemoteClient) Health(arg0 context.Context) (*coretypes.ResultHealth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Health", arg0)
	ret0, _ := ret[0].(*coretypes.ResultHealth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NetInfo mocks base method.
func (m *MockRemoteClient) NetInfo(arg0 context.Context) (*coretypes.ResultNetInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NetInfo", arg0)
	ret0, _ := ret[0].(*coretypes.ResultNetInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// NumUnconfirmedTxs mocks base method.
func (m *MockRemoteClient) NumUnconfirmedTxs(arg0 context.Context) (*coretypes.ResultUnconfirmedTxs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NumUnconfirmedTxs", arg0)
	ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetLogger mocks base method.
func (m *MockRemoteClient) SetLogger(arg0 log.Logger) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLogger", arg0)
}

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

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

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

// Status mocks base method.
func (m *MockRemoteClient) Status(arg0 context.Context) (*coretypes.ResultStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status", arg0)
	ret0, _ := ret[0].(*coretypes.ResultStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

// Subscribe mocks base method.
func (m *MockRemoteClient) Subscribe(ctx context.Context, subscriber, query string, outCapacity ...int) (<-chan coretypes.ResultEvent, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, subscriber, query}
	for _, a := range outCapacity {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Subscribe", varargs...)
	ret0, _ := ret[0].(<-chan coretypes.ResultEvent)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Subscribe indicates an expected call of Subscribe.
func (mr *MockRemoteClientMockRecorder) Subscribe(ctx, subscriber, query any, outCapacity ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, subscriber, query}, outCapacity...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Subscribe", reflect.TypeOf((*MockRemoteClient)(nil).Subscribe), varargs...)
}

// Tx mocks base method.
func (m *MockRemoteClient) Tx(ctx context.Context, hash []byte, prove bool) (*coretypes.ResultTx, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tx", ctx, hash, prove)
	ret0, _ := ret[0].(*coretypes.ResultTx)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Tx indicates an expected call of Tx.
func (mr *MockRemoteClientMockRecorder) Tx(ctx, hash, prove any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Tx", reflect.TypeOf((*MockRemoteClient)(nil).Tx), ctx, hash, prove)
}

// TxSearch mocks base method.
func (m *MockRemoteClient) TxSearch(ctx context.Context, query string, prove bool, page, perPage *int, orderBy string) (*coretypes.ResultTxSearch, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TxSearch", ctx, query, prove, page, perPage, orderBy)
	ret0, _ := ret[0].(*coretypes.ResultTxSearch)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// TxSearch indicates an expected call of TxSearch.
func (mr *MockRemoteClientMockRecorder) TxSearch(ctx, query, prove, page, perPage, orderBy any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TxSearch", reflect.TypeOf((*MockRemoteClient)(nil).TxSearch), ctx, query, prove, page, perPage, orderBy)
}

// UnconfirmedTxs mocks base method.
func (m *MockRemoteClient) UnconfirmedTxs(ctx context.Context, limit *int) (*coretypes.ResultUnconfirmedTxs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UnconfirmedTxs", ctx, limit)
	ret0, _ := ret[0].(*coretypes.ResultUnconfirmedTxs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UnconfirmedTxs indicates an expected call of UnconfirmedTxs.
func (mr *MockRemoteClientMockRecorder) UnconfirmedTxs(ctx, limit any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnconfirmedTxs", reflect.TypeOf((*MockRemoteClient)(nil).UnconfirmedTxs), ctx, limit)
}

// Unsubscribe mocks base method.
func (m *MockRemoteClient) Unsubscribe(ctx context.Context, subscriber, query string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Unsubscribe", ctx, subscriber, query)
	ret0, _ := ret[0].(error)
	return ret0
}

// Unsubscribe indicates an expected call of Unsubscribe.
func (mr *MockRemoteClientMockRecorder) Unsubscribe(ctx, subscriber, query any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unsubscribe", reflect.TypeOf((*MockRemoteClient)(nil).Unsubscribe), ctx, subscriber, query)
}

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

// UnsubscribeAll indicates an expected call of UnsubscribeAll.
func (mr *MockRemoteClientMockRecorder) UnsubscribeAll(ctx, subscriber any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsubscribeAll", reflect.TypeOf((*MockRemoteClient)(nil).UnsubscribeAll), ctx, subscriber)
}

// Validators mocks base method.
func (m *MockRemoteClient) Validators(ctx context.Context, height *int64, page, perPage *int) (*coretypes.ResultValidators, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Validators", ctx, height, page, perPage)
	ret0, _ := ret[0].(*coretypes.ResultValidators)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Validators indicates an expected call of Validators.
func (mr *MockRemoteClientMockRecorder) Validators(ctx, height, page, perPage any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Validators", reflect.TypeOf((*MockRemoteClient)(nil).Validators), ctx, height, page, perPage)
}

// MockBothanClient is a mock of BothanClient interface.
type MockBothanClient struct {
	ctrl     *gomock.Controller
	recorder *MockBothanClientMockRecorder
	isgomock struct{}
}

// MockBothanClientMockRecorder is the mock recorder for MockBothanClient.
type MockBothanClientMockRecorder struct {
	mock *MockBothanClient
}

// NewMockBothanClient creates a new mock instance.
func NewMockBothanClient(ctrl *gomock.Controller) *MockBothanClient {
	mock := &MockBothanClient{ctrl: ctrl}
	mock.recorder = &MockBothanClientMockRecorder{mock}
	return mock
}

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

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

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

// GetPrices mocks base method.
func (m *MockBothanClient) GetPrices(signalIDs []string) (*proto.GetPricesResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPrices", signalIDs)
	ret0, _ := ret[0].(*proto.GetPricesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPrices indicates an expected call of GetPrices.
func (mr *MockBothanClientMockRecorder) GetPrices(signalIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPrices", reflect.TypeOf((*MockBothanClient)(nil).GetPrices), signalIDs)
}

// PushMonitoringRecords mocks base method.
func (m *MockBothanClient) PushMonitoringRecords(uuid, txHash string, signalIDs []string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushMonitoringRecords", uuid, txHash, signalIDs)
	ret0, _ := ret[0].(error)
	return ret0
}

// PushMonitoringRecords indicates an expected call of PushMonitoringRecords.
func (mr *MockBothanClientMockRecorder) PushMonitoringRecords(uuid, txHash, signalIDs any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushMonitoringRecords", reflect.TypeOf((*MockBothanClient)(nil).PushMonitoringRecords), uuid, txHash, signalIDs)
}

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

// UpdateRegistry indicates an expected call of UpdateRegistry.
func (mr *MockBothanClientMockRecorder) UpdateRegistry(ipfsHash, version any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateRegistry", reflect.TypeOf((*MockBothanClient)(nil).UpdateRegistry), ipfsHash, version)
}

// MockAuthQuerier is a mock of AuthQuerier interface.
type MockAuthQuerier struct {
	ctrl     *gomock.Controller
	recorder *MockAuthQuerierMockRecorder
	isgomock struct{}
}

// MockAuthQuerierMockRecorder is the mock recorder for MockAuthQuerier.
type MockAuthQuerierMockRecorder struct {
	mock *MockAuthQuerier
}

// NewMockAuthQuerier creates a new mock instance.
func NewMockAuthQuerier(ctrl *gomock.Controller) *MockAuthQuerier {
	mock := &MockAuthQuerier{ctrl: ctrl}
	mock.recorder = &MockAuthQuerierMockRecorder{mock}
	return mock
}

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

// QueryAccount mocks base method.
func (m *MockAuthQuerier) QueryAccount(address types0.Address) (*types1.QueryAccountResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryAccount", address)
	ret0, _ := ret[0].(*types1.QueryAccountResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryAccount indicates an expected call of QueryAccount.
func (mr *MockAuthQuerierMockRecorder) QueryAccount(address any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryAccount", reflect.TypeOf((*MockAuthQuerier)(nil).QueryAccount), address)
}

// MockTxQuerier is a mock of TxQuerier interface.
type MockTxQuerier struct {
	ctrl     *gomock.Controller
	recorder *MockTxQuerierMockRecorder
	isgomock struct{}
}

// MockTxQuerierMockRecorder is the mock recorder for MockTxQuerier.
type MockTxQuerierMockRecorder struct {
	mock *MockTxQuerier
}

// NewMockTxQuerier creates a new mock instance.
func NewMockTxQuerier(ctrl *gomock.Controller) *MockTxQuerier {
	mock := &MockTxQuerier{ctrl: ctrl}
	mock.recorder = &MockTxQuerierMockRecorder{mock}
	return mock
}

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

// QueryTx mocks base method.
func (m *MockTxQuerier) QueryTx(hash string) (*types0.TxResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryTx", hash)
	ret0, _ := ret[0].(*types0.TxResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryTx indicates an expected call of QueryTx.
func (mr *MockTxQuerierMockRecorder) QueryTx(hash any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryTx", reflect.TypeOf((*MockTxQuerier)(nil).QueryTx), hash)
}
