// Code generated by MockGen. DO NOT EDIT.
// Source: x/swingset/types/expected_keepers.go
//
// Generated by this command:
//
//	mockgen -source=x/swingset/types/expected_keepers.go -package testutil -destination x/swingset/testutil/mocks.go
//

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

import (
	context "context"
	reflect "reflect"

	math "cosmossdk.io/math"
	types "github.com/Agoric/agoric-sdk/golang/cosmos/types"
	types0 "github.com/Agoric/agoric-sdk/golang/cosmos/x/swingset/types"
	types1 "github.com/cosmos/cosmos-sdk/types"
	gomock "go.uber.org/mock/gomock"
)

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

// 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 context.Context, addr types1.AccAddress) types1.AccountI {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAccount", ctx, addr)
	ret0, _ := ret[0].(types1.AccountI)
	return ret0
}

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

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

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

// SetAccount mocks base method.
func (m *MockAccountKeeper) SetAccount(ctx context.Context, acc types1.AccountI) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAccount", ctx, acc)
}

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

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

// 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 context.Context, addr types1.AccAddress) types1.Coins {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllBalances", ctx, addr)
	ret0, _ := ret[0].(types1.Coins)
	return ret0
}

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

// SendCoinsFromAccountToModule mocks base method.
func (m *MockBankKeeper) SendCoinsFromAccountToModule(ctx context.Context, senderAddr types1.AccAddress, recipientModule string, amt types1.Coins) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SendCoinsFromAccountToModule", ctx, senderAddr, recipientModule, amt)
	ret0, _ := ret[0].(error)
	return ret0
}

// SendCoinsFromAccountToModule indicates an expected call of SendCoinsFromAccountToModule.
func (mr *MockBankKeeperMockRecorder) SendCoinsFromAccountToModule(ctx, senderAddr, recipientModule, amt any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromAccountToModule", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromAccountToModule), ctx, senderAddr, recipientModule, amt)
}

// MockVstorageKeeper is a mock of VstorageKeeper interface.
type MockVstorageKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockVstorageKeeperMockRecorder
	isgomock struct{}
}

// MockVstorageKeeperMockRecorder is the mock recorder for MockVstorageKeeper.
type MockVstorageKeeperMockRecorder struct {
	mock *MockVstorageKeeper
}

// NewMockVstorageKeeper creates a new mock instance.
func NewMockVstorageKeeper(ctrl *gomock.Controller) *MockVstorageKeeper {
	mock := &MockVstorageKeeper{ctrl: ctrl}
	mock.recorder = &MockVstorageKeeperMockRecorder{mock}
	return mock
}

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

// GetChildren mocks base method.
func (m *MockVstorageKeeper) GetChildren(ctx types1.Context, path string) []string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetChildren", ctx, path)
	ret0, _ := ret[0].([]string)
	return ret0
}

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

// GetEntry mocks base method.
func (m *MockVstorageKeeper) GetEntry(ctx types1.Context, path string) types.KVEntry {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetEntry", ctx, path)
	ret0, _ := ret[0].(types.KVEntry)
	return ret0
}

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

// GetQueueLength mocks base method.
func (m *MockVstorageKeeper) GetQueueLength(ctx types1.Context, path string) (math.Int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueLength", ctx, path)
	ret0, _ := ret[0].(math.Int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// HasEntry mocks base method.
func (m *MockVstorageKeeper) HasEntry(ctx types1.Context, path string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasEntry", ctx, path)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// LegacySetStorageAndNotify mocks base method.
func (m *MockVstorageKeeper) LegacySetStorageAndNotify(ctx types1.Context, entry types.KVEntry) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "LegacySetStorageAndNotify", ctx, entry)
}

// LegacySetStorageAndNotify indicates an expected call of LegacySetStorageAndNotify.
func (mr *MockVstorageKeeperMockRecorder) LegacySetStorageAndNotify(ctx, entry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LegacySetStorageAndNotify", reflect.TypeOf((*MockVstorageKeeper)(nil).LegacySetStorageAndNotify), ctx, entry)
}

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

// PathToEncodedKey indicates an expected call of PathToEncodedKey.
func (mr *MockVstorageKeeperMockRecorder) PathToEncodedKey(path any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PathToEncodedKey", reflect.TypeOf((*MockVstorageKeeper)(nil).PathToEncodedKey), path)
}

// PushQueueItem mocks base method.
func (m *MockVstorageKeeper) PushQueueItem(ctx types1.Context, path, value string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushQueueItem", ctx, path, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// PushQueueItem indicates an expected call of PushQueueItem.
func (mr *MockVstorageKeeperMockRecorder) PushQueueItem(ctx, path, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushQueueItem", reflect.TypeOf((*MockVstorageKeeper)(nil).PushQueueItem), ctx, path, value)
}

// SetStorage mocks base method.
func (m *MockVstorageKeeper) SetStorage(ctx types1.Context, entry types.KVEntry) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStorage", ctx, entry)
}

// SetStorage indicates an expected call of SetStorage.
func (mr *MockVstorageKeeperMockRecorder) SetStorage(ctx, entry any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStorage", reflect.TypeOf((*MockVstorageKeeper)(nil).SetStorage), ctx, entry)
}

// MockSwingSetKeeper is a mock of SwingSetKeeper interface.
type MockSwingSetKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockSwingSetKeeperMockRecorder
	isgomock struct{}
}

// MockSwingSetKeeperMockRecorder is the mock recorder for MockSwingSetKeeper.
type MockSwingSetKeeperMockRecorder struct {
	mock *MockSwingSetKeeper
}

// NewMockSwingSetKeeper creates a new mock instance.
func NewMockSwingSetKeeper(ctrl *gomock.Controller) *MockSwingSetKeeper {
	mock := &MockSwingSetKeeper{ctrl: ctrl}
	mock.recorder = &MockSwingSetKeeperMockRecorder{mock}
	return mock
}

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

// ChargeBeans mocks base method.
func (m *MockSwingSetKeeper) ChargeBeans(ctx types1.Context, beansPerUnit map[string]math.Uint, addr types1.AccAddress, beans math.Uint) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChargeBeans", ctx, beansPerUnit, addr, beans)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChargeBeans indicates an expected call of ChargeBeans.
func (mr *MockSwingSetKeeperMockRecorder) ChargeBeans(ctx, beansPerUnit, addr, beans any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChargeBeans", reflect.TypeOf((*MockSwingSetKeeper)(nil).ChargeBeans), ctx, beansPerUnit, addr, beans)
}

// ChargeForSmartWallet mocks base method.
func (m *MockSwingSetKeeper) ChargeForSmartWallet(ctx types1.Context, beansPerUnit map[string]math.Uint, addr types1.AccAddress) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ChargeForSmartWallet", ctx, beansPerUnit, addr)
	ret0, _ := ret[0].(error)
	return ret0
}

// ChargeForSmartWallet indicates an expected call of ChargeForSmartWallet.
func (mr *MockSwingSetKeeperMockRecorder) ChargeForSmartWallet(ctx, beansPerUnit, addr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ChargeForSmartWallet", reflect.TypeOf((*MockSwingSetKeeper)(nil).ChargeForSmartWallet), ctx, beansPerUnit, addr)
}

// GetBeansPerUnit mocks base method.
func (m *MockSwingSetKeeper) GetBeansPerUnit(ctx types1.Context) map[string]math.Uint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBeansPerUnit", ctx)
	ret0, _ := ret[0].(map[string]math.Uint)
	return ret0
}

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

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

// GetSmartWalletState indicates an expected call of GetSmartWalletState.
func (mr *MockSwingSetKeeperMockRecorder) GetSmartWalletState(ctx, addr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSmartWalletState", reflect.TypeOf((*MockSwingSetKeeper)(nil).GetSmartWalletState), ctx, addr)
}

// IsHighPriorityAddress mocks base method.
func (m *MockSwingSetKeeper) IsHighPriorityAddress(ctx types1.Context, addr types1.AccAddress) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsHighPriorityAddress", ctx, addr)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsHighPriorityAddress indicates an expected call of IsHighPriorityAddress.
func (mr *MockSwingSetKeeperMockRecorder) IsHighPriorityAddress(ctx, addr any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsHighPriorityAddress", reflect.TypeOf((*MockSwingSetKeeper)(nil).IsHighPriorityAddress), ctx, addr)
}
