code.vegaprotocol.io/vega@v0.79.0/core/governance/mocks/mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: code.vegaprotocol.io/vega/core/governance (interfaces: Markets,StakingAccounts,Assets,TimeService,Witness,NetParams,Banking)

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

import (
	context "context"
	reflect "reflect"
	time "time"

	assets "code.vegaprotocol.io/vega/core/assets"
	netparams "code.vegaprotocol.io/vega/core/netparams"
	types "code.vegaprotocol.io/vega/core/types"
	validators "code.vegaprotocol.io/vega/core/validators"
	num "code.vegaprotocol.io/vega/libs/num"
	vega "code.vegaprotocol.io/vega/protos/vega"
	gomock "github.com/golang/mock/gomock"
	decimal "github.com/shopspring/decimal"
)

// MockMarkets is a mock of Markets interface.
type MockMarkets struct {
	ctrl     *gomock.Controller
	recorder *MockMarketsMockRecorder
}

// MockMarketsMockRecorder is the mock recorder for MockMarkets.
type MockMarketsMockRecorder struct {
	mock *MockMarkets
}

// NewMockMarkets creates a new mock instance.
func NewMockMarkets(ctrl *gomock.Controller) *MockMarkets {
	mock := &MockMarkets{ctrl: ctrl}
	mock.recorder = &MockMarketsMockRecorder{mock}
	return mock
}

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

// GetEquityLikeShareForMarketAndParty mocks base method.
func (m *MockMarkets) GetEquityLikeShareForMarketAndParty(arg0, arg1 string) (decimal.Decimal, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEquityLikeShareForMarketAndParty", arg0, arg1)
	ret0, _ := ret[0].(decimal.Decimal)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// GetMarket mocks base method.
func (m *MockMarkets) GetMarket(arg0 string, arg1 bool) (types.Market, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMarket", arg0, arg1)
	ret0, _ := ret[0].(types.Market)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

// GetMarketState mocks base method.
func (m *MockMarkets) GetMarketState(arg0 string) (vega.Market_State, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMarketState", arg0)
	ret0, _ := ret[0].(vega.Market_State)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

// RestoreMarket mocks base method.
func (m *MockMarkets) RestoreMarket(arg0 context.Context, arg1 *types.Market) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreMarket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// UpdateMarket mocks base method.
func (m *MockMarkets) UpdateMarket(arg0 context.Context, arg1 *types.Market) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateMarket", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ValidateSettlementData mocks base method.
func (m *MockMarkets) ValidateSettlementData(arg0 string, arg1 *num.Uint) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateSettlementData", arg0, arg1)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// MockStakingAccounts is a mock of StakingAccounts interface.
type MockStakingAccounts struct {
	ctrl     *gomock.Controller
	recorder *MockStakingAccountsMockRecorder
}

// MockStakingAccountsMockRecorder is the mock recorder for MockStakingAccounts.
type MockStakingAccountsMockRecorder struct {
	mock *MockStakingAccounts
}

// NewMockStakingAccounts creates a new mock instance.
func NewMockStakingAccounts(ctrl *gomock.Controller) *MockStakingAccounts {
	mock := &MockStakingAccounts{ctrl: ctrl}
	mock.recorder = &MockStakingAccountsMockRecorder{mock}
	return mock
}

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

// GetAvailableBalance mocks base method.
func (m *MockStakingAccounts) GetAvailableBalance(arg0 string) (*num.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAvailableBalance", arg0)
	ret0, _ := ret[0].(*num.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetStakingAssetTotalSupply mocks base method.
func (m *MockStakingAccounts) GetStakingAssetTotalSupply() *num.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStakingAssetTotalSupply")
	ret0, _ := ret[0].(*num.Uint)
	return ret0
}

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

// MockAssets is a mock of Assets interface.
type MockAssets struct {
	ctrl     *gomock.Controller
	recorder *MockAssetsMockRecorder
}

// MockAssetsMockRecorder is the mock recorder for MockAssets.
type MockAssetsMockRecorder struct {
	mock *MockAssets
}

// NewMockAssets creates a new mock instance.
func NewMockAssets(ctrl *gomock.Controller) *MockAssets {
	mock := &MockAssets{ctrl: ctrl}
	mock.recorder = &MockAssetsMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockAssets) Get(arg0 string) (*assets.Asset, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(*assets.Asset)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// NewAsset mocks base method.
func (m *MockAssets) NewAsset(arg0 context.Context, arg1 string, arg2 *types.AssetDetails) (string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAsset", arg0, arg1, arg2)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewAsset indicates an expected call of NewAsset.
func (mr *MockAssetsMockRecorder) NewAsset(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAsset", reflect.TypeOf((*MockAssets)(nil).NewAsset), arg0, arg1, arg2)
}

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

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

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

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

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

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

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

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

// MockTimeService is a mock of TimeService interface.
type MockTimeService struct {
	ctrl     *gomock.Controller
	recorder *MockTimeServiceMockRecorder
}

// MockTimeServiceMockRecorder is the mock recorder for MockTimeService.
type MockTimeServiceMockRecorder struct {
	mock *MockTimeService
}

// NewMockTimeService creates a new mock instance.
func NewMockTimeService(ctrl *gomock.Controller) *MockTimeService {
	mock := &MockTimeService{ctrl: ctrl}
	mock.recorder = &MockTimeServiceMockRecorder{mock}
	return mock
}

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

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

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

// MockWitness is a mock of Witness interface.
type MockWitness struct {
	ctrl     *gomock.Controller
	recorder *MockWitnessMockRecorder
}

// MockWitnessMockRecorder is the mock recorder for MockWitness.
type MockWitnessMockRecorder struct {
	mock *MockWitness
}

// NewMockWitness creates a new mock instance.
func NewMockWitness(ctrl *gomock.Controller) *MockWitness {
	mock := &MockWitness{ctrl: ctrl}
	mock.recorder = &MockWitnessMockRecorder{mock}
	return mock
}

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

// RestoreResource mocks base method.
func (m *MockWitness) RestoreResource(arg0 validators.Resource, arg1 func(interface{}, bool)) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestoreResource", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StartCheck mocks base method.
func (m *MockWitness) StartCheck(arg0 validators.Resource, arg1 func(interface{}, bool), arg2 time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartCheck", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartCheck indicates an expected call of StartCheck.
func (mr *MockWitnessMockRecorder) StartCheck(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartCheck", reflect.TypeOf((*MockWitness)(nil).StartCheck), arg0, arg1, arg2)
}

// MockNetParams is a mock of NetParams interface.
type MockNetParams struct {
	ctrl     *gomock.Controller
	recorder *MockNetParamsMockRecorder
}

// MockNetParamsMockRecorder is the mock recorder for MockNetParams.
type MockNetParamsMockRecorder struct {
	mock *MockNetParams
}

// NewMockNetParams creates a new mock instance.
func NewMockNetParams(ctrl *gomock.Controller) *MockNetParams {
	mock := &MockNetParams{ctrl: ctrl}
	mock.recorder = &MockNetParamsMockRecorder{mock}
	return mock
}

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

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

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

// GetDecimal mocks base method.
func (m *MockNetParams) GetDecimal(arg0 string) (decimal.Decimal, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDecimal", arg0)
	ret0, _ := ret[0].(decimal.Decimal)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetDuration mocks base method.
func (m *MockNetParams) GetDuration(arg0 string) (time.Duration, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDuration", arg0)
	ret0, _ := ret[0].(time.Duration)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// GetUint mocks base method.
func (m *MockNetParams) GetUint(arg0 string) (*num.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetUint", arg0)
	ret0, _ := ret[0].(*num.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Update mocks base method.
func (m *MockNetParams) Update(arg0 context.Context, arg1, arg2 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

// Update indicates an expected call of Update.
func (mr *MockNetParamsMockRecorder) Update(arg0, arg1, arg2 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockNetParams)(nil).Update), arg0, arg1, arg2)
}

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

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

// MockBanking is a mock of Banking interface.
type MockBanking struct {
	ctrl     *gomock.Controller
	recorder *MockBankingMockRecorder
}

// MockBankingMockRecorder is the mock recorder for MockBanking.
type MockBankingMockRecorder struct {
	mock *MockBanking
}

// NewMockBanking creates a new mock instance.
func NewMockBanking(ctrl *gomock.Controller) *MockBanking {
	mock := &MockBanking{ctrl: ctrl}
	mock.recorder = &MockBankingMockRecorder{mock}
	return mock
}

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

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

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

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

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