// Code generated by MockGen. DO NOT EDIT.
// Source: x/storage/types/expected_keepers.go

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

import (
	context "context"
	big "math/big"
	reflect "reflect"
	time "time"

	math "cosmossdk.io/math"
	types "github.com/bnb-chain/greenfield/types"
	resource "github.com/bnb-chain/greenfield/types/resource"
	types0 "github.com/bnb-chain/greenfield/x/payment/types"
	types1 "github.com/bnb-chain/greenfield/x/permission/types"
	types2 "github.com/bnb-chain/greenfield/x/sp/types"
	types3 "github.com/bnb-chain/greenfield/x/virtualgroup/types"
	log "github.com/cometbft/cometbft/libs/log"
	types4 "github.com/cosmos/cosmos-sdk/types"
	types5 "github.com/cosmos/cosmos-sdk/x/auth/types"
	gomock "github.com/golang/mock/gomock"
)

// MockAccountKeeper is a mock of AccountKeeper interface.
type MockAccountKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockAccountKeeperMockRecorder
}

// MockAccountKeeperMockRecorder is the mock recorder for MockAccountKeeper.
type MockAccountKeeperMockRecorder struct {
	mock *MockAccountKeeper
}

// NewMockAccountKeeper creates a new mock instance.
func NewMockAccountKeeper(ctrl *gomock.Controller) *MockAccountKeeper {
	mock := &MockAccountKeeper{ctrl: ctrl}
	mock.recorder = &MockAccountKeeperMockRecorder{mock}
	return mock
}

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

// GetAccount mocks base method.
func (m *MockAccountKeeper) GetAccount(ctx types4.Context, addr types4.AccAddress) types5.AccountI {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccount", ctx, addr)
	ret0, _ := ret[0].(types5.AccountI)
	return ret0
}

// GetAccount indicates an expected call of GetAccount.
func (mr *MockAccountKeeperMockRecorder) GetAccount(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccount", reflect.TypeOf((*MockAccountKeeper)(nil).GetAccount), ctx, addr)
}

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

// GetModuleAddress indicates an expected call of GetModuleAddress.
func (mr *MockAccountKeeperMockRecorder) GetModuleAddress(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetModuleAddress", reflect.TypeOf((*MockAccountKeeper)(nil).GetModuleAddress), name)
}

// MockBankKeeper is a mock of BankKeeper interface.
type MockBankKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockBankKeeperMockRecorder
}

// MockBankKeeperMockRecorder is the mock recorder for MockBankKeeper.
type MockBankKeeperMockRecorder struct {
	mock *MockBankKeeper
}

// NewMockBankKeeper creates a new mock instance.
func NewMockBankKeeper(ctrl *gomock.Controller) *MockBankKeeper {
	mock := &MockBankKeeper{ctrl: ctrl}
	mock.recorder = &MockBankKeeperMockRecorder{mock}
	return mock
}

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

// GetAllBalances mocks base method.
func (m *MockBankKeeper) GetAllBalances(ctx types4.Context, addr types4.AccAddress) types4.Coins {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr)
	ret0, _ := ret[0].(types4.Coins)
	return ret0
}

// GetAllBalances indicates an expected call of GetAllBalances.
func (mr *MockBankKeeperMockRecorder) GetAllBalances(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBalances", reflect.TypeOf((*MockBankKeeper)(nil).GetAllBalances), ctx, addr)
}

// GetBalance mocks base method.
func (m *MockBankKeeper) GetBalance(ctx types4.Context, addr types4.AccAddress, denom string) types4.Coin {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBalance", ctx, addr, denom)
	ret0, _ := ret[0].(types4.Coin)
	return ret0
}

// GetBalance indicates an expected call of GetBalance.
func (mr *MockBankKeeperMockRecorder) GetBalance(ctx, addr, denom interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBalance", reflect.TypeOf((*MockBankKeeper)(nil).GetBalance), ctx, addr, denom)
}

// SendCoinsFromModuleToAccount mocks base method.
func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx types4.Context, senderModule string, recipientAddr types4.AccAddress, amt types4.Coins) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendCoinsFromModuleToAccount", ctx, senderModule, recipientAddr, amt)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendCoinsFromModuleToAccount indicates an expected call of SendCoinsFromModuleToAccount.
func (mr *MockBankKeeperMockRecorder) SendCoinsFromModuleToAccount(ctx, senderModule, recipientAddr, amt interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt)
}

// SpendableCoins mocks base method.
func (m *MockBankKeeper) SpendableCoins(ctx types4.Context, addr types4.AccAddress) types4.Coins {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SpendableCoins", ctx, addr)
	ret0, _ := ret[0].(types4.Coins)
	return ret0
}

// SpendableCoins indicates an expected call of SpendableCoins.
func (mr *MockBankKeeperMockRecorder) SpendableCoins(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SpendableCoins", reflect.TypeOf((*MockBankKeeper)(nil).SpendableCoins), ctx, addr)
}

// MockSpKeeper is a mock of SpKeeper interface.
type MockSpKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockSpKeeperMockRecorder
}

// MockSpKeeperMockRecorder is the mock recorder for MockSpKeeper.
type MockSpKeeperMockRecorder struct {
	mock *MockSpKeeper
}

// NewMockSpKeeper creates a new mock instance.
func NewMockSpKeeper(ctrl *gomock.Controller) *MockSpKeeper {
	mock := &MockSpKeeper{ctrl: ctrl}
	mock.recorder = &MockSpKeeperMockRecorder{mock}
	return mock
}

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

// GetGlobalSpStorePriceByTime mocks base method.
func (m *MockSpKeeper) GetGlobalSpStorePriceByTime(ctx types4.Context, time int64) (types2.GlobalSpStorePrice, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGlobalSpStorePriceByTime", ctx, time)
	ret0, _ := ret[0].(types2.GlobalSpStorePrice)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGlobalSpStorePriceByTime indicates an expected call of GetGlobalSpStorePriceByTime.
func (mr *MockSpKeeperMockRecorder) GetGlobalSpStorePriceByTime(ctx, time interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalSpStorePriceByTime", reflect.TypeOf((*MockSpKeeper)(nil).GetGlobalSpStorePriceByTime), ctx, time)
}

// GetStorageProvider mocks base method.
func (m *MockSpKeeper) GetStorageProvider(ctx types4.Context, id uint32) (*types2.StorageProvider, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageProvider", ctx, id)
	ret0, _ := ret[0].(*types2.StorageProvider)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStorageProvider indicates an expected call of GetStorageProvider.
func (mr *MockSpKeeperMockRecorder) GetStorageProvider(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageProvider", reflect.TypeOf((*MockSpKeeper)(nil).GetStorageProvider), ctx, id)
}

// GetStorageProviderByGcAddr mocks base method.
func (m *MockSpKeeper) GetStorageProviderByGcAddr(ctx types4.Context, gcAddr types4.AccAddress) (*types2.StorageProvider, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageProviderByGcAddr", ctx, gcAddr)
	ret0, _ := ret[0].(*types2.StorageProvider)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStorageProviderByGcAddr indicates an expected call of GetStorageProviderByGcAddr.
func (mr *MockSpKeeperMockRecorder) GetStorageProviderByGcAddr(ctx, gcAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageProviderByGcAddr", reflect.TypeOf((*MockSpKeeper)(nil).GetStorageProviderByGcAddr), ctx, gcAddr)
}

// GetStorageProviderByOperatorAddr mocks base method.
func (m *MockSpKeeper) GetStorageProviderByOperatorAddr(ctx types4.Context, addr types4.AccAddress) (*types2.StorageProvider, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageProviderByOperatorAddr", ctx, addr)
	ret0, _ := ret[0].(*types2.StorageProvider)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStorageProviderByOperatorAddr indicates an expected call of GetStorageProviderByOperatorAddr.
func (mr *MockSpKeeperMockRecorder) GetStorageProviderByOperatorAddr(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageProviderByOperatorAddr", reflect.TypeOf((*MockSpKeeper)(nil).GetStorageProviderByOperatorAddr), ctx, addr)
}

// GetStorageProviderBySealAddr mocks base method.
func (m *MockSpKeeper) GetStorageProviderBySealAddr(ctx types4.Context, sealAddr types4.AccAddress) (*types2.StorageProvider, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStorageProviderBySealAddr", ctx, sealAddr)
	ret0, _ := ret[0].(*types2.StorageProvider)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStorageProviderBySealAddr indicates an expected call of GetStorageProviderBySealAddr.
func (mr *MockSpKeeperMockRecorder) GetStorageProviderBySealAddr(ctx, sealAddr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStorageProviderBySealAddr", reflect.TypeOf((*MockSpKeeper)(nil).GetStorageProviderBySealAddr), ctx, sealAddr)
}

// MustGetStorageProvider mocks base method.
func (m *MockSpKeeper) MustGetStorageProvider(ctx types4.Context, id uint32) *types2.StorageProvider {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MustGetStorageProvider", ctx, id)
	ret0, _ := ret[0].(*types2.StorageProvider)
	return ret0
}

// MustGetStorageProvider indicates an expected call of MustGetStorageProvider.
func (mr *MockSpKeeperMockRecorder) MustGetStorageProvider(ctx, id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MustGetStorageProvider", reflect.TypeOf((*MockSpKeeper)(nil).MustGetStorageProvider), ctx, id)
}

// MockPaymentKeeper is a mock of PaymentKeeper interface.
type MockPaymentKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockPaymentKeeperMockRecorder
}

// MockPaymentKeeperMockRecorder is the mock recorder for MockPaymentKeeper.
type MockPaymentKeeperMockRecorder struct {
	mock *MockPaymentKeeper
}

// NewMockPaymentKeeper creates a new mock instance.
func NewMockPaymentKeeper(ctrl *gomock.Controller) *MockPaymentKeeper {
	mock := &MockPaymentKeeper{ctrl: ctrl}
	mock.recorder = &MockPaymentKeeperMockRecorder{mock}
	return mock
}

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

// ApplyUserFlowsList mocks base method.
func (m *MockPaymentKeeper) ApplyUserFlowsList(ctx types4.Context, userFlows []types0.UserFlows) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ApplyUserFlowsList", ctx, userFlows)
	ret0, _ := ret[0].(error)
	return ret0
}

// ApplyUserFlowsList indicates an expected call of ApplyUserFlowsList.
func (mr *MockPaymentKeeperMockRecorder) ApplyUserFlowsList(ctx, userFlows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplyUserFlowsList", reflect.TypeOf((*MockPaymentKeeper)(nil).ApplyUserFlowsList), ctx, userFlows)
}

// GetAllStreamRecord mocks base method.
func (m *MockPaymentKeeper) GetAllStreamRecord(ctx types4.Context) []types0.StreamRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllStreamRecord", ctx)
	ret0, _ := ret[0].([]types0.StreamRecord)
	return ret0
}

// GetAllStreamRecord indicates an expected call of GetAllStreamRecord.
func (mr *MockPaymentKeeperMockRecorder) GetAllStreamRecord(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllStreamRecord", reflect.TypeOf((*MockPaymentKeeper)(nil).GetAllStreamRecord), ctx)
}

// GetOutFlows mocks base method.
func (m *MockPaymentKeeper) GetOutFlows(ctx types4.Context, addr types4.AccAddress) []types0.OutFlow {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOutFlows", ctx, addr)
	ret0, _ := ret[0].([]types0.OutFlow)
	return ret0
}

// GetOutFlows indicates an expected call of GetOutFlows.
func (mr *MockPaymentKeeperMockRecorder) GetOutFlows(ctx, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOutFlows", reflect.TypeOf((*MockPaymentKeeper)(nil).GetOutFlows), ctx, addr)
}

// GetStreamRecord mocks base method.
func (m *MockPaymentKeeper) GetStreamRecord(ctx types4.Context, account types4.AccAddress) (*types0.StreamRecord, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetStreamRecord", ctx, account)
	ret0, _ := ret[0].(*types0.StreamRecord)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetStreamRecord indicates an expected call of GetStreamRecord.
func (mr *MockPaymentKeeperMockRecorder) GetStreamRecord(ctx, account interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetStreamRecord", reflect.TypeOf((*MockPaymentKeeper)(nil).GetStreamRecord), ctx, account)
}

// GetVersionedParamsWithTs mocks base method.
func (m *MockPaymentKeeper) GetVersionedParamsWithTs(ctx types4.Context, time int64) (types0.VersionedParams, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVersionedParamsWithTs", ctx, time)
	ret0, _ := ret[0].(types0.VersionedParams)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVersionedParamsWithTs indicates an expected call of GetVersionedParamsWithTs.
func (mr *MockPaymentKeeperMockRecorder) GetVersionedParamsWithTs(ctx, time interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersionedParamsWithTs", reflect.TypeOf((*MockPaymentKeeper)(nil).GetVersionedParamsWithTs), ctx, time)
}

// IsPaymentAccountOwner mocks base method.
func (m *MockPaymentKeeper) IsPaymentAccountOwner(ctx types4.Context, addr, owner types4.AccAddress) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsPaymentAccountOwner", ctx, addr, owner)
	ret0, _ := ret[0].(bool)
	return ret0
}

// IsPaymentAccountOwner indicates an expected call of IsPaymentAccountOwner.
func (mr *MockPaymentKeeperMockRecorder) IsPaymentAccountOwner(ctx, addr, owner interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsPaymentAccountOwner", reflect.TypeOf((*MockPaymentKeeper)(nil).IsPaymentAccountOwner), ctx, addr, owner)
}

// MergeOutFlows mocks base method.
func (m *MockPaymentKeeper) MergeOutFlows(flows []types0.OutFlow) []types0.OutFlow {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MergeOutFlows", flows)
	ret0, _ := ret[0].([]types0.OutFlow)
	return ret0
}

// MergeOutFlows indicates an expected call of MergeOutFlows.
func (mr *MockPaymentKeeperMockRecorder) MergeOutFlows(flows interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeOutFlows", reflect.TypeOf((*MockPaymentKeeper)(nil).MergeOutFlows), flows)
}

// UpdateStreamRecordByAddr mocks base method.
func (m *MockPaymentKeeper) UpdateStreamRecordByAddr(ctx types4.Context, change *types0.StreamRecordChange) (*types0.StreamRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateStreamRecordByAddr", ctx, change)
	ret0, _ := ret[0].(*types0.StreamRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateStreamRecordByAddr indicates an expected call of UpdateStreamRecordByAddr.
func (mr *MockPaymentKeeperMockRecorder) UpdateStreamRecordByAddr(ctx, change interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateStreamRecordByAddr", reflect.TypeOf((*MockPaymentKeeper)(nil).UpdateStreamRecordByAddr), ctx, change)
}

// MockPermissionKeeper is a mock of PermissionKeeper interface.
type MockPermissionKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockPermissionKeeperMockRecorder
}

// MockPermissionKeeperMockRecorder is the mock recorder for MockPermissionKeeper.
type MockPermissionKeeperMockRecorder struct {
	mock *MockPermissionKeeper
}

// NewMockPermissionKeeper creates a new mock instance.
func NewMockPermissionKeeper(ctrl *gomock.Controller) *MockPermissionKeeper {
	mock := &MockPermissionKeeper{ctrl: ctrl}
	mock.recorder = &MockPermissionKeeperMockRecorder{mock}
	return mock
}

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

// AddGroupMember mocks base method.
func (m *MockPermissionKeeper) AddGroupMember(ctx types4.Context, groupID math.Uint, member types4.AccAddress, expiration *time.Time) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddGroupMember", ctx, groupID, member, expiration)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddGroupMember indicates an expected call of AddGroupMember.
func (mr *MockPermissionKeeperMockRecorder) AddGroupMember(ctx, groupID, member, expiration interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddGroupMember", reflect.TypeOf((*MockPermissionKeeper)(nil).AddGroupMember), ctx, groupID, member, expiration)
}

// DeletePolicy mocks base method.
func (m *MockPermissionKeeper) DeletePolicy(ctx types4.Context, principal *types1.Principal, resourceType resource.ResourceType, resourceID math.Uint) (math.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeletePolicy", ctx, principal, resourceType, resourceID)
	ret0, _ := ret[0].(math.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeletePolicy indicates an expected call of DeletePolicy.
func (mr *MockPermissionKeeperMockRecorder) DeletePolicy(ctx, principal, resourceType, resourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePolicy", reflect.TypeOf((*MockPermissionKeeper)(nil).DeletePolicy), ctx, principal, resourceType, resourceID)
}

// ExistAccountPolicyForResource mocks base method.
func (m *MockPermissionKeeper) ExistAccountPolicyForResource(ctx types4.Context, resourceType resource.ResourceType, resourceID math.Uint) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistAccountPolicyForResource", ctx, resourceType, resourceID)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExistAccountPolicyForResource indicates an expected call of ExistAccountPolicyForResource.
func (mr *MockPermissionKeeperMockRecorder) ExistAccountPolicyForResource(ctx, resourceType, resourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistAccountPolicyForResource", reflect.TypeOf((*MockPermissionKeeper)(nil).ExistAccountPolicyForResource), ctx, resourceType, resourceID)
}

// ExistGroupMemberForGroup mocks base method.
func (m *MockPermissionKeeper) ExistGroupMemberForGroup(ctx types4.Context, groupId math.Uint) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistGroupMemberForGroup", ctx, groupId)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExistGroupMemberForGroup indicates an expected call of ExistGroupMemberForGroup.
func (mr *MockPermissionKeeperMockRecorder) ExistGroupMemberForGroup(ctx, groupId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistGroupMemberForGroup", reflect.TypeOf((*MockPermissionKeeper)(nil).ExistGroupMemberForGroup), ctx, groupId)
}

// ExistGroupPolicyForResource mocks base method.
func (m *MockPermissionKeeper) ExistGroupPolicyForResource(ctx types4.Context, resourceType resource.ResourceType, resourceID math.Uint) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ExistGroupPolicyForResource", ctx, resourceType, resourceID)
	ret0, _ := ret[0].(bool)
	return ret0
}

// ExistGroupPolicyForResource indicates an expected call of ExistGroupPolicyForResource.
func (mr *MockPermissionKeeperMockRecorder) ExistGroupPolicyForResource(ctx, resourceType, resourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExistGroupPolicyForResource", reflect.TypeOf((*MockPermissionKeeper)(nil).ExistGroupPolicyForResource), ctx, resourceType, resourceID)
}

// ForceDeleteAccountPolicyForResource mocks base method.
func (m *MockPermissionKeeper) ForceDeleteAccountPolicyForResource(ctx types4.Context, maxDelete, deletedCount uint64, resourceType resource.ResourceType, resourceID math.Uint) (uint64, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceDeleteAccountPolicyForResource", ctx, maxDelete, deletedCount, resourceType, resourceID)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// ForceDeleteAccountPolicyForResource indicates an expected call of ForceDeleteAccountPolicyForResource.
func (mr *MockPermissionKeeperMockRecorder) ForceDeleteAccountPolicyForResource(ctx, maxDelete, deletedCount, resourceType, resourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceDeleteAccountPolicyForResource", reflect.TypeOf((*MockPermissionKeeper)(nil).ForceDeleteAccountPolicyForResource), ctx, maxDelete, deletedCount, resourceType, resourceID)
}

// ForceDeleteGroupMembers mocks base method.
func (m *MockPermissionKeeper) ForceDeleteGroupMembers(ctx types4.Context, maxDelete, deletedTotal uint64, groupId math.Uint) (uint64, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceDeleteGroupMembers", ctx, maxDelete, deletedTotal, groupId)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// ForceDeleteGroupMembers indicates an expected call of ForceDeleteGroupMembers.
func (mr *MockPermissionKeeperMockRecorder) ForceDeleteGroupMembers(ctx, maxDelete, deletedTotal, groupId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceDeleteGroupMembers", reflect.TypeOf((*MockPermissionKeeper)(nil).ForceDeleteGroupMembers), ctx, maxDelete, deletedTotal, groupId)
}

// ForceDeleteGroupPolicyForResource mocks base method.
func (m *MockPermissionKeeper) ForceDeleteGroupPolicyForResource(ctx types4.Context, maxDelete, deletedCount uint64, resourceType resource.ResourceType, resourceID math.Uint) (uint64, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ForceDeleteGroupPolicyForResource", ctx, maxDelete, deletedCount, resourceType, resourceID)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// ForceDeleteGroupPolicyForResource indicates an expected call of ForceDeleteGroupPolicyForResource.
func (mr *MockPermissionKeeperMockRecorder) ForceDeleteGroupPolicyForResource(ctx, maxDelete, deletedCount, resourceType, resourceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForceDeleteGroupPolicyForResource", reflect.TypeOf((*MockPermissionKeeper)(nil).ForceDeleteGroupPolicyForResource), ctx, maxDelete, deletedCount, resourceType, resourceID)
}

// GetGroupMember mocks base method.
func (m *MockPermissionKeeper) GetGroupMember(ctx types4.Context, groupID math.Uint, member types4.AccAddress) (*types1.GroupMember, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMember", ctx, groupID, member)
	ret0, _ := ret[0].(*types1.GroupMember)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetGroupMember indicates an expected call of GetGroupMember.
func (mr *MockPermissionKeeperMockRecorder) GetGroupMember(ctx, groupID, member interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMember", reflect.TypeOf((*MockPermissionKeeper)(nil).GetGroupMember), ctx, groupID, member)
}

// GetGroupMemberByID mocks base method.
func (m *MockPermissionKeeper) GetGroupMemberByID(ctx types4.Context, groupMemberID math.Uint) (*types1.GroupMember, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupMemberByID", ctx, groupMemberID)
	ret0, _ := ret[0].(*types1.GroupMember)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetGroupMemberByID indicates an expected call of GetGroupMemberByID.
func (mr *MockPermissionKeeperMockRecorder) GetGroupMemberByID(ctx, groupMemberID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupMemberByID", reflect.TypeOf((*MockPermissionKeeper)(nil).GetGroupMemberByID), ctx, groupMemberID)
}

// GetPolicyByID mocks base method.
func (m *MockPermissionKeeper) GetPolicyByID(ctx types4.Context, policyID math.Uint) (*types1.Policy, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyByID", ctx, policyID)
	ret0, _ := ret[0].(*types1.Policy)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetPolicyByID indicates an expected call of GetPolicyByID.
func (mr *MockPermissionKeeperMockRecorder) GetPolicyByID(ctx, policyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyByID", reflect.TypeOf((*MockPermissionKeeper)(nil).GetPolicyByID), ctx, policyID)
}

// GetPolicyForAccount mocks base method.
func (m *MockPermissionKeeper) GetPolicyForAccount(ctx types4.Context, resourceID math.Uint, resourceType resource.ResourceType, addr types4.AccAddress) (*types1.Policy, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyForAccount", ctx, resourceID, resourceType, addr)
	ret0, _ := ret[0].(*types1.Policy)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetPolicyForAccount indicates an expected call of GetPolicyForAccount.
func (mr *MockPermissionKeeperMockRecorder) GetPolicyForAccount(ctx, resourceID, resourceType, addr interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyForAccount", reflect.TypeOf((*MockPermissionKeeper)(nil).GetPolicyForAccount), ctx, resourceID, resourceType, addr)
}

// GetPolicyForGroup mocks base method.
func (m *MockPermissionKeeper) GetPolicyForGroup(ctx types4.Context, resourceID math.Uint, resourceType resource.ResourceType, groupID math.Uint) (*types1.Policy, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyForGroup", ctx, resourceID, resourceType, groupID)
	ret0, _ := ret[0].(*types1.Policy)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetPolicyForGroup indicates an expected call of GetPolicyForGroup.
func (mr *MockPermissionKeeperMockRecorder) GetPolicyForGroup(ctx, resourceID, resourceType, groupID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyForGroup", reflect.TypeOf((*MockPermissionKeeper)(nil).GetPolicyForGroup), ctx, resourceID, resourceType, groupID)
}

// GetPolicyGroupForResource mocks base method.
func (m *MockPermissionKeeper) GetPolicyGroupForResource(ctx types4.Context, resourceID math.Uint, resourceType resource.ResourceType) (*types1.PolicyGroup, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPolicyGroupForResource", ctx, resourceID, resourceType)
	ret0, _ := ret[0].(*types1.PolicyGroup)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetPolicyGroupForResource indicates an expected call of GetPolicyGroupForResource.
func (mr *MockPermissionKeeperMockRecorder) GetPolicyGroupForResource(ctx, resourceID, resourceType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPolicyGroupForResource", reflect.TypeOf((*MockPermissionKeeper)(nil).GetPolicyGroupForResource), ctx, resourceID, resourceType)
}

// MustGetPolicyByID mocks base method.
func (m *MockPermissionKeeper) MustGetPolicyByID(ctx types4.Context, policyID math.Uint) *types1.Policy {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MustGetPolicyByID", ctx, policyID)
	ret0, _ := ret[0].(*types1.Policy)
	return ret0
}

// MustGetPolicyByID indicates an expected call of MustGetPolicyByID.
func (mr *MockPermissionKeeperMockRecorder) MustGetPolicyByID(ctx, policyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MustGetPolicyByID", reflect.TypeOf((*MockPermissionKeeper)(nil).MustGetPolicyByID), ctx, policyID)
}

// PutPolicy mocks base method.
func (m *MockPermissionKeeper) PutPolicy(ctx types4.Context, policy *types1.Policy) (math.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutPolicy", ctx, policy)
	ret0, _ := ret[0].(math.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutPolicy indicates an expected call of PutPolicy.
func (mr *MockPermissionKeeperMockRecorder) PutPolicy(ctx, policy interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutPolicy", reflect.TypeOf((*MockPermissionKeeper)(nil).PutPolicy), ctx, policy)
}

// RemoveGroupMember mocks base method.
func (m *MockPermissionKeeper) RemoveGroupMember(ctx types4.Context, groupID math.Uint, member types4.AccAddress) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveGroupMember", ctx, groupID, member)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveGroupMember indicates an expected call of RemoveGroupMember.
func (mr *MockPermissionKeeperMockRecorder) RemoveGroupMember(ctx, groupID, member interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveGroupMember", reflect.TypeOf((*MockPermissionKeeper)(nil).RemoveGroupMember), ctx, groupID, member)
}

// UpdateGroupMember mocks base method.
func (m *MockPermissionKeeper) UpdateGroupMember(ctx types4.Context, groupID math.Uint, member types4.AccAddress, memberID math.Uint, expiration *time.Time) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "UpdateGroupMember", ctx, groupID, member, memberID, expiration)
}

// UpdateGroupMember indicates an expected call of UpdateGroupMember.
func (mr *MockPermissionKeeperMockRecorder) UpdateGroupMember(ctx, groupID, member, memberID, expiration interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupMember", reflect.TypeOf((*MockPermissionKeeper)(nil).UpdateGroupMember), ctx, groupID, member, memberID, expiration)
}

// MockCrossChainKeeper is a mock of CrossChainKeeper interface.
type MockCrossChainKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockCrossChainKeeperMockRecorder
}

// MockCrossChainKeeperMockRecorder is the mock recorder for MockCrossChainKeeper.
type MockCrossChainKeeperMockRecorder struct {
	mock *MockCrossChainKeeper
}

// NewMockCrossChainKeeper creates a new mock instance.
func NewMockCrossChainKeeper(ctrl *gomock.Controller) *MockCrossChainKeeper {
	mock := &MockCrossChainKeeper{ctrl: ctrl}
	mock.recorder = &MockCrossChainKeeperMockRecorder{mock}
	return mock
}

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

// CreateRawIBCPackageWithFee mocks base method.
func (m *MockCrossChainKeeper) CreateRawIBCPackageWithFee(ctx types4.Context, chainID types4.ChainID, channelID types4.ChannelID, packageType types4.CrossChainPackageType, packageLoad []byte, relayerFee, ackRelayerFee *big.Int) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateRawIBCPackageWithFee", ctx, chainID, channelID, packageType, packageLoad, relayerFee, ackRelayerFee)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateRawIBCPackageWithFee indicates an expected call of CreateRawIBCPackageWithFee.
func (mr *MockCrossChainKeeperMockRecorder) CreateRawIBCPackageWithFee(ctx, chainID, channelID, packageType, packageLoad, relayerFee, ackRelayerFee interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRawIBCPackageWithFee", reflect.TypeOf((*MockCrossChainKeeper)(nil).CreateRawIBCPackageWithFee), ctx, chainID, channelID, packageType, packageLoad, relayerFee, ackRelayerFee)
}

// GetDestBscChainID mocks base method.
func (m *MockCrossChainKeeper) GetDestBscChainID() types4.ChainID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDestBscChainID")
	ret0, _ := ret[0].(types4.ChainID)
	return ret0
}

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

// GetDestOpChainID mocks base method.
func (m *MockCrossChainKeeper) GetDestOpChainID() types4.ChainID {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDestOpChainID")
	ret0, _ := ret[0].(types4.ChainID)
	return ret0
}

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

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

// IsDestChainSupported indicates an expected call of IsDestChainSupported.
func (mr *MockCrossChainKeeperMockRecorder) IsDestChainSupported(chainID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsDestChainSupported", reflect.TypeOf((*MockCrossChainKeeper)(nil).IsDestChainSupported), chainID)
}

// RegisterChannel mocks base method.
func (m *MockCrossChainKeeper) RegisterChannel(name string, id types4.ChannelID, app types4.CrossChainApplication) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterChannel", name, id, app)
	ret0, _ := ret[0].(error)
	return ret0
}

// RegisterChannel indicates an expected call of RegisterChannel.
func (mr *MockCrossChainKeeperMockRecorder) RegisterChannel(name, id, app interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterChannel", reflect.TypeOf((*MockCrossChainKeeper)(nil).RegisterChannel), name, id, app)
}

// MockVirtualGroupKeeper is a mock of VirtualGroupKeeper interface.
type MockVirtualGroupKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockVirtualGroupKeeperMockRecorder
}

// MockVirtualGroupKeeperMockRecorder is the mock recorder for MockVirtualGroupKeeper.
type MockVirtualGroupKeeperMockRecorder struct {
	mock *MockVirtualGroupKeeper
}

// NewMockVirtualGroupKeeper creates a new mock instance.
func NewMockVirtualGroupKeeper(ctrl *gomock.Controller) *MockVirtualGroupKeeper {
	mock := &MockVirtualGroupKeeper{ctrl: ctrl}
	mock.recorder = &MockVirtualGroupKeeperMockRecorder{mock}
	return mock
}

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

// GetAndCheckGVGFamilyAvailableForNewBucket mocks base method.
func (m *MockVirtualGroupKeeper) GetAndCheckGVGFamilyAvailableForNewBucket(ctx types4.Context, familyID uint32) (*types3.GlobalVirtualGroupFamily, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAndCheckGVGFamilyAvailableForNewBucket", ctx, familyID)
	ret0, _ := ret[0].(*types3.GlobalVirtualGroupFamily)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAndCheckGVGFamilyAvailableForNewBucket indicates an expected call of GetAndCheckGVGFamilyAvailableForNewBucket.
func (mr *MockVirtualGroupKeeperMockRecorder) GetAndCheckGVGFamilyAvailableForNewBucket(ctx, familyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAndCheckGVGFamilyAvailableForNewBucket", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).GetAndCheckGVGFamilyAvailableForNewBucket), ctx, familyID)
}

// GetGVG mocks base method.
func (m *MockVirtualGroupKeeper) GetGVG(ctx types4.Context, gvgID uint32) (*types3.GlobalVirtualGroup, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGVG", ctx, gvgID)
	ret0, _ := ret[0].(*types3.GlobalVirtualGroup)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetGVG indicates an expected call of GetGVG.
func (mr *MockVirtualGroupKeeperMockRecorder) GetGVG(ctx, gvgID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGVG", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).GetGVG), ctx, gvgID)
}

// GetGVGFamily mocks base method.
func (m *MockVirtualGroupKeeper) GetGVGFamily(ctx types4.Context, familyID uint32) (*types3.GlobalVirtualGroupFamily, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGVGFamily", ctx, familyID)
	ret0, _ := ret[0].(*types3.GlobalVirtualGroupFamily)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetGVGFamily indicates an expected call of GetGVGFamily.
func (mr *MockVirtualGroupKeeperMockRecorder) GetGVGFamily(ctx, familyID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGVGFamily", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).GetGVGFamily), ctx, familyID)
}

// GetGlobalVirtualGroupIfAvailable mocks base method.
func (m *MockVirtualGroupKeeper) GetGlobalVirtualGroupIfAvailable(ctx types4.Context, gvgID uint32, expectedStoreSize uint64) (*types3.GlobalVirtualGroup, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGlobalVirtualGroupIfAvailable", ctx, gvgID, expectedStoreSize)
	ret0, _ := ret[0].(*types3.GlobalVirtualGroup)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetGlobalVirtualGroupIfAvailable indicates an expected call of GetGlobalVirtualGroupIfAvailable.
func (mr *MockVirtualGroupKeeperMockRecorder) GetGlobalVirtualGroupIfAvailable(ctx, gvgID, expectedStoreSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGlobalVirtualGroupIfAvailable", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).GetGlobalVirtualGroupIfAvailable), ctx, gvgID, expectedStoreSize)
}

// GetSwapInInfo mocks base method.
func (m *MockVirtualGroupKeeper) GetSwapInInfo(ctx types4.Context, familyID, gvgID uint32) (*types3.SwapInInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSwapInInfo", ctx, familyID, gvgID)
	ret0, _ := ret[0].(*types3.SwapInInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetSwapInInfo indicates an expected call of GetSwapInInfo.
func (mr *MockVirtualGroupKeeperMockRecorder) GetSwapInInfo(ctx, familyID, gvgID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSwapInInfo", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).GetSwapInInfo), ctx, familyID, gvgID)
}

// SetGVGAndEmitUpdateEvent mocks base method.
func (m *MockVirtualGroupKeeper) SetGVGAndEmitUpdateEvent(ctx types4.Context, gvg *types3.GlobalVirtualGroup) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetGVGAndEmitUpdateEvent", ctx, gvg)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetGVGAndEmitUpdateEvent indicates an expected call of SetGVGAndEmitUpdateEvent.
func (mr *MockVirtualGroupKeeperMockRecorder) SetGVGAndEmitUpdateEvent(ctx, gvg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGVGAndEmitUpdateEvent", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).SetGVGAndEmitUpdateEvent), ctx, gvg)
}

// SettleAndDistributeGVG mocks base method.
func (m *MockVirtualGroupKeeper) SettleAndDistributeGVG(ctx types4.Context, gvg *types3.GlobalVirtualGroup) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SettleAndDistributeGVG", ctx, gvg)
	ret0, _ := ret[0].(error)
	return ret0
}

// SettleAndDistributeGVG indicates an expected call of SettleAndDistributeGVG.
func (mr *MockVirtualGroupKeeperMockRecorder) SettleAndDistributeGVG(ctx, gvg interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettleAndDistributeGVG", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).SettleAndDistributeGVG), ctx, gvg)
}

// SettleAndDistributeGVGFamily mocks base method.
func (m *MockVirtualGroupKeeper) SettleAndDistributeGVGFamily(ctx types4.Context, sp *types2.StorageProvider, family *types3.GlobalVirtualGroupFamily) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SettleAndDistributeGVGFamily", ctx, sp, family)
	ret0, _ := ret[0].(error)
	return ret0
}

// SettleAndDistributeGVGFamily indicates an expected call of SettleAndDistributeGVGFamily.
func (mr *MockVirtualGroupKeeperMockRecorder) SettleAndDistributeGVGFamily(ctx, sp, family interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SettleAndDistributeGVGFamily", reflect.TypeOf((*MockVirtualGroupKeeper)(nil).SettleAndDistributeGVGFamily), ctx, sp, family)
}

// MockStorageKeeper is a mock of StorageKeeper interface.
type MockStorageKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockStorageKeeperMockRecorder
}

// MockStorageKeeperMockRecorder is the mock recorder for MockStorageKeeper.
type MockStorageKeeperMockRecorder struct {
	mock *MockStorageKeeper
}

// NewMockStorageKeeper creates a new mock instance.
func NewMockStorageKeeper(ctrl *gomock.Controller) *MockStorageKeeper {
	mock := &MockStorageKeeper{ctrl: ctrl}
	mock.recorder = &MockStorageKeeperMockRecorder{mock}
	return mock
}

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

// CreateBucket mocks base method.
func (m *MockStorageKeeper) CreateBucket(ctx types4.Context, ownerAcc types4.AccAddress, bucketName string, primarySpAcc types4.AccAddress, opts *CreateBucketOptions) (math.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateBucket", ctx, ownerAcc, bucketName, primarySpAcc, opts)
	ret0, _ := ret[0].(math.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateBucket indicates an expected call of CreateBucket.
func (mr *MockStorageKeeperMockRecorder) CreateBucket(ctx, ownerAcc, bucketName, primarySpAcc, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockStorageKeeper)(nil).CreateBucket), ctx, ownerAcc, bucketName, primarySpAcc, opts)
}

// CreateGroup mocks base method.
func (m *MockStorageKeeper) CreateGroup(ctx types4.Context, owner types4.AccAddress, groupName string, opts CreateGroupOptions) (math.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroup", ctx, owner, groupName, opts)
	ret0, _ := ret[0].(math.Uint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGroup indicates an expected call of CreateGroup.
func (mr *MockStorageKeeperMockRecorder) CreateGroup(ctx, owner, groupName, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroup", reflect.TypeOf((*MockStorageKeeper)(nil).CreateGroup), ctx, owner, groupName, opts)
}

// DeleteBucket mocks base method.
func (m *MockStorageKeeper) DeleteBucket(ctx types4.Context, operator types4.AccAddress, bucketName string, opts DeleteBucketOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBucket", ctx, operator, bucketName, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBucket indicates an expected call of DeleteBucket.
func (mr *MockStorageKeeperMockRecorder) DeleteBucket(ctx, operator, bucketName, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockStorageKeeper)(nil).DeleteBucket), ctx, operator, bucketName, opts)
}

// DeleteGroup mocks base method.
func (m *MockStorageKeeper) DeleteGroup(ctx types4.Context, operator types4.AccAddress, groupName string, opts DeleteGroupOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteGroup", ctx, operator, groupName, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteGroup indicates an expected call of DeleteGroup.
func (mr *MockStorageKeeperMockRecorder) DeleteGroup(ctx, operator, groupName, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteGroup", reflect.TypeOf((*MockStorageKeeper)(nil).DeleteGroup), ctx, operator, groupName, opts)
}

// DeleteObject mocks base method.
func (m *MockStorageKeeper) DeleteObject(ctx types4.Context, operator types4.AccAddress, bucketName, objectName string, opts DeleteObjectOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteObject", ctx, operator, bucketName, objectName, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteObject indicates an expected call of DeleteObject.
func (mr *MockStorageKeeperMockRecorder) DeleteObject(ctx, operator, bucketName, objectName, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockStorageKeeper)(nil).DeleteObject), ctx, operator, bucketName, objectName, opts)
}

// GetBucketInfo mocks base method.
func (m *MockStorageKeeper) GetBucketInfo(ctx types4.Context, bucketName string) (*BucketInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketInfo", ctx, bucketName)
	ret0, _ := ret[0].(*BucketInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetBucketInfo indicates an expected call of GetBucketInfo.
func (mr *MockStorageKeeperMockRecorder) GetBucketInfo(ctx, bucketName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInfo", reflect.TypeOf((*MockStorageKeeper)(nil).GetBucketInfo), ctx, bucketName)
}

// GetBucketInfoById mocks base method.
func (m *MockStorageKeeper) GetBucketInfoById(ctx types4.Context, bucketId math.Uint) (*BucketInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBucketInfoById", ctx, bucketId)
	ret0, _ := ret[0].(*BucketInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetBucketInfoById indicates an expected call of GetBucketInfoById.
func (mr *MockStorageKeeperMockRecorder) GetBucketInfoById(ctx, bucketId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBucketInfoById", reflect.TypeOf((*MockStorageKeeper)(nil).GetBucketInfoById), ctx, bucketId)
}

// GetGroupInfo mocks base method.
func (m *MockStorageKeeper) GetGroupInfo(ctx types4.Context, ownerAddr types4.AccAddress, groupName string) (*GroupInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupInfo", ctx, ownerAddr, groupName)
	ret0, _ := ret[0].(*GroupInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetGroupInfo indicates an expected call of GetGroupInfo.
func (mr *MockStorageKeeperMockRecorder) GetGroupInfo(ctx, ownerAddr, groupName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupInfo", reflect.TypeOf((*MockStorageKeeper)(nil).GetGroupInfo), ctx, ownerAddr, groupName)
}

// GetGroupInfoById mocks base method.
func (m *MockStorageKeeper) GetGroupInfoById(ctx types4.Context, groupId math.Uint) (*GroupInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroupInfoById", ctx, groupId)
	ret0, _ := ret[0].(*GroupInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetGroupInfoById indicates an expected call of GetGroupInfoById.
func (mr *MockStorageKeeperMockRecorder) GetGroupInfoById(ctx, groupId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetGroupInfoById", reflect.TypeOf((*MockStorageKeeper)(nil).GetGroupInfoById), ctx, groupId)
}

// GetObjectInfo mocks base method.
func (m *MockStorageKeeper) GetObjectInfo(ctx types4.Context, bucketName, objectName string) (*ObjectInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectInfo", ctx, bucketName, objectName)
	ret0, _ := ret[0].(*ObjectInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetObjectInfo indicates an expected call of GetObjectInfo.
func (mr *MockStorageKeeperMockRecorder) GetObjectInfo(ctx, bucketName, objectName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectInfo", reflect.TypeOf((*MockStorageKeeper)(nil).GetObjectInfo), ctx, bucketName, objectName)
}

// GetObjectInfoById mocks base method.
func (m *MockStorageKeeper) GetObjectInfoById(ctx types4.Context, objectId math.Uint) (*ObjectInfo, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetObjectInfoById", ctx, objectId)
	ret0, _ := ret[0].(*ObjectInfo)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// GetObjectInfoById indicates an expected call of GetObjectInfoById.
func (mr *MockStorageKeeperMockRecorder) GetObjectInfoById(ctx, objectId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectInfoById", reflect.TypeOf((*MockStorageKeeper)(nil).GetObjectInfoById), ctx, objectId)
}

// GetResourceOwnerAndIdFromGRN mocks base method.
func (m *MockStorageKeeper) GetResourceOwnerAndIdFromGRN(ctx types4.Context, grn types.GRN) (types4.AccAddress, math.Uint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetResourceOwnerAndIdFromGRN", ctx, grn)
	ret0, _ := ret[0].(types4.AccAddress)
	ret1, _ := ret[1].(math.Uint)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetResourceOwnerAndIdFromGRN indicates an expected call of GetResourceOwnerAndIdFromGRN.
func (mr *MockStorageKeeperMockRecorder) GetResourceOwnerAndIdFromGRN(ctx, grn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceOwnerAndIdFromGRN", reflect.TypeOf((*MockStorageKeeper)(nil).GetResourceOwnerAndIdFromGRN), ctx, grn)
}

// GetSourceTypeByChainId mocks base method.
func (m *MockStorageKeeper) GetSourceTypeByChainId(ctx types4.Context, chainId types4.ChainID) (SourceType, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSourceTypeByChainId", ctx, chainId)
	ret0, _ := ret[0].(SourceType)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSourceTypeByChainId indicates an expected call of GetSourceTypeByChainId.
func (mr *MockStorageKeeperMockRecorder) GetSourceTypeByChainId(ctx, chainId interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSourceTypeByChainId", reflect.TypeOf((*MockStorageKeeper)(nil).GetSourceTypeByChainId), ctx, chainId)
}

// Logger mocks base method.
func (m *MockStorageKeeper) Logger(ctx types4.Context) log.Logger {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Logger", ctx)
	ret0, _ := ret[0].(log.Logger)
	return ret0
}

// Logger indicates an expected call of Logger.
func (mr *MockStorageKeeperMockRecorder) Logger(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Logger", reflect.TypeOf((*MockStorageKeeper)(nil).Logger), ctx)
}

// NormalizePrincipal mocks base method.
func (m *MockStorageKeeper) NormalizePrincipal(ctx types4.Context, principal *types1.Principal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "NormalizePrincipal", ctx, principal)
}

// NormalizePrincipal indicates an expected call of NormalizePrincipal.
func (mr *MockStorageKeeperMockRecorder) NormalizePrincipal(ctx, principal interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NormalizePrincipal", reflect.TypeOf((*MockStorageKeeper)(nil).NormalizePrincipal), ctx, principal)
}

// RenewGroupMember mocks base method.
func (m *MockStorageKeeper) RenewGroupMember(ctx types4.Context, operator types4.AccAddress, groupInfo *GroupInfo, opts RenewGroupMemberOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenewGroupMember", ctx, operator, groupInfo, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// RenewGroupMember indicates an expected call of RenewGroupMember.
func (mr *MockStorageKeeperMockRecorder) RenewGroupMember(ctx, operator, groupInfo, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RenewGroupMember", reflect.TypeOf((*MockStorageKeeper)(nil).RenewGroupMember), ctx, operator, groupInfo, opts)
}

// SetBucketInfo mocks base method.
func (m *MockStorageKeeper) SetBucketInfo(ctx types4.Context, bucketInfo *BucketInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBucketInfo", ctx, bucketInfo)
}

// SetBucketInfo indicates an expected call of SetBucketInfo.
func (mr *MockStorageKeeperMockRecorder) SetBucketInfo(ctx, bucketInfo interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBucketInfo", reflect.TypeOf((*MockStorageKeeper)(nil).SetBucketInfo), ctx, bucketInfo)
}

// SetGroupInfo mocks base method.
func (m *MockStorageKeeper) SetGroupInfo(ctx types4.Context, groupInfo *GroupInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetGroupInfo", ctx, groupInfo)
}

// SetGroupInfo indicates an expected call of SetGroupInfo.
func (mr *MockStorageKeeperMockRecorder) SetGroupInfo(ctx, groupInfo interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetGroupInfo", reflect.TypeOf((*MockStorageKeeper)(nil).SetGroupInfo), ctx, groupInfo)
}

// SetObjectInfo mocks base method.
func (m *MockStorageKeeper) SetObjectInfo(ctx types4.Context, objectInfo *ObjectInfo) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetObjectInfo", ctx, objectInfo)
}

// SetObjectInfo indicates an expected call of SetObjectInfo.
func (mr *MockStorageKeeperMockRecorder) SetObjectInfo(ctx, objectInfo interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetObjectInfo", reflect.TypeOf((*MockStorageKeeper)(nil).SetObjectInfo), ctx, objectInfo)
}

// UpdateGroupMember mocks base method.
func (m *MockStorageKeeper) UpdateGroupMember(ctx types4.Context, operator types4.AccAddress, groupInfo *GroupInfo, opts UpdateGroupMemberOptions) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroupMember", ctx, operator, groupInfo, opts)
	ret0, _ := ret[0].(error)
	return ret0
}

// UpdateGroupMember indicates an expected call of UpdateGroupMember.
func (mr *MockStorageKeeperMockRecorder) UpdateGroupMember(ctx, operator, groupInfo, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateGroupMember", reflect.TypeOf((*MockStorageKeeper)(nil).UpdateGroupMember), ctx, operator, groupInfo, opts)
}

// ValidatePrincipal mocks base method.
func (m *MockStorageKeeper) ValidatePrincipal(ctx types4.Context, resOwner types4.AccAddress, principal *types1.Principal) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatePrincipal", ctx, resOwner, principal)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidatePrincipal indicates an expected call of ValidatePrincipal.
func (mr *MockStorageKeeperMockRecorder) ValidatePrincipal(ctx, resOwner, principal interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatePrincipal", reflect.TypeOf((*MockStorageKeeper)(nil).ValidatePrincipal), ctx, resOwner, principal)
}

// MockPaymentMsgServer is a mock of PaymentMsgServer interface.
type MockPaymentMsgServer struct {
	ctrl     *gomock.Controller
	recorder *MockPaymentMsgServerMockRecorder
}

// MockPaymentMsgServerMockRecorder is the mock recorder for MockPaymentMsgServer.
type MockPaymentMsgServerMockRecorder struct {
	mock *MockPaymentMsgServer
}

// NewMockPaymentMsgServer creates a new mock instance.
func NewMockPaymentMsgServer(ctrl *gomock.Controller) *MockPaymentMsgServer {
	mock := &MockPaymentMsgServer{ctrl: ctrl}
	mock.recorder = &MockPaymentMsgServerMockRecorder{mock}
	return mock
}

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

// CreatePaymentAccount mocks base method.
func (m *MockPaymentMsgServer) CreatePaymentAccount(arg0 context.Context, arg1 *types0.MsgCreatePaymentAccount) (*types0.MsgCreatePaymentAccountResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreatePaymentAccount", arg0, arg1)
	ret0, _ := ret[0].(*types0.MsgCreatePaymentAccountResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Deposit mocks base method.
func (m *MockPaymentMsgServer) Deposit(arg0 context.Context, arg1 *types0.MsgDeposit) (*types0.MsgDepositResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Deposit", arg0, arg1)
	ret0, _ := ret[0].(*types0.MsgDepositResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableRefund mocks base method.
func (m *MockPaymentMsgServer) DisableRefund(arg0 context.Context, arg1 *types0.MsgDisableRefund) (*types0.MsgDisableRefundResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableRefund", arg0, arg1)
	ret0, _ := ret[0].(*types0.MsgDisableRefundResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// Withdraw mocks base method.
func (m *MockPaymentMsgServer) Withdraw(arg0 context.Context, arg1 *types0.MsgWithdraw) (*types0.MsgWithdrawResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Withdraw", arg0, arg1)
	ret0, _ := ret[0].(*types0.MsgWithdrawResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockStorageMsgServer is a mock of StorageMsgServer interface.
type MockStorageMsgServer struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMsgServerMockRecorder
}

// MockStorageMsgServerMockRecorder is the mock recorder for MockStorageMsgServer.
type MockStorageMsgServerMockRecorder struct {
	mock *MockStorageMsgServer
}

// NewMockStorageMsgServer creates a new mock instance.
func NewMockStorageMsgServer(ctrl *gomock.Controller) *MockStorageMsgServer {
	mock := &MockStorageMsgServer{ctrl: ctrl}
	mock.recorder = &MockStorageMsgServerMockRecorder{mock}
	return mock
}

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

// CancelMigrateBucket mocks base method.
func (m *MockStorageMsgServer) CancelMigrateBucket(arg0 context.Context, arg1 *MsgCancelMigrateBucket) (*MsgCancelMigrateBucketResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CancelMigrateBucket", arg0, arg1)
	ret0, _ := ret[0].(*MsgCancelMigrateBucketResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CopyObject mocks base method.
func (m *MockStorageMsgServer) CopyObject(arg0 context.Context, arg1 *MsgCopyObject) (*MsgCopyObjectResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyObject", arg0, arg1)
	ret0, _ := ret[0].(*MsgCopyObjectResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MigrateBucket mocks base method.
func (m *MockStorageMsgServer) MigrateBucket(arg0 context.Context, arg1 *MsgMigrateBucket) (*MsgMigrateBucketResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MigrateBucket", arg0, arg1)
	ret0, _ := ret[0].(*MsgMigrateBucketResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetBucketFlowRateLimit mocks base method.
func (m *MockStorageMsgServer) SetBucketFlowRateLimit(arg0 context.Context, arg1 *MsgSetBucketFlowRateLimit) (*MsgSetBucketFlowRateLimitResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBucketFlowRateLimit", arg0, arg1)
	ret0, _ := ret[0].(*MsgSetBucketFlowRateLimitResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetTag mocks base method.
func (m *MockStorageMsgServer) SetTag(arg0 context.Context, arg1 *MsgSetTag) (*MsgSetTagResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetTag", arg0, arg1)
	ret0, _ := ret[0].(*MsgSetTagResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ToggleSPAsDelegatedAgent mocks base method.
func (m *MockStorageMsgServer) ToggleSPAsDelegatedAgent(arg0 context.Context, arg1 *MsgToggleSPAsDelegatedAgent) (*MsgToggleSPAsDelegatedAgentResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToggleSPAsDelegatedAgent", arg0, arg1)
	ret0, _ := ret[0].(*MsgToggleSPAsDelegatedAgentResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateBucketInfo mocks base method.
func (m *MockStorageMsgServer) UpdateBucketInfo(arg0 context.Context, arg1 *MsgUpdateBucketInfo) (*MsgUpdateBucketInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateBucketInfo", arg0, arg1)
	ret0, _ := ret[0].(*MsgUpdateBucketInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateGroupExtra mocks base method.
func (m *MockStorageMsgServer) UpdateGroupExtra(arg0 context.Context, arg1 *MsgUpdateGroupExtra) (*MsgUpdateGroupExtraResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateGroupExtra", arg0, arg1)
	ret0, _ := ret[0].(*MsgUpdateGroupExtraResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateObjectInfo mocks base method.
func (m *MockStorageMsgServer) UpdateObjectInfo(arg0 context.Context, arg1 *MsgUpdateObjectInfo) (*MsgUpdateObjectInfoResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateObjectInfo", arg0, arg1)
	ret0, _ := ret[0].(*MsgUpdateObjectInfoResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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