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

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

import (
	context "context"
	reflect "reflect"

	math "cosmossdk.io/math"
	tss "github.com/bandprotocol/chain/v3/pkg/tss"
	types "github.com/bandprotocol/chain/v3/x/tss/types"
	types0 "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
}

// GetModuleAccount mocks base method.
func (m *MockAccountKeeper) GetModuleAccount(ctx context.Context, name string) types0.ModuleAccountI {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetModuleAccount", ctx, name)
	ret0, _ := ret[0].(types0.ModuleAccountI)
	return ret0
}

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

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

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

// SetModuleAccount mocks base method.
func (m *MockAccountKeeper) SetModuleAccount(arg0 context.Context, arg1 types0.ModuleAccountI) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetModuleAccount", arg0, arg1)
}

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

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

// SendCoinsFromModuleToAccount mocks base method.
func (m *MockBankKeeper) SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr types0.AccAddress, amt types0.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 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendCoinsFromModuleToAccount", reflect.TypeOf((*MockBankKeeper)(nil).SendCoinsFromModuleToAccount), ctx, senderModule, recipientAddr, amt)
}

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

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

// MockDistrKeeper is a mock of DistrKeeper interface.
type MockDistrKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockDistrKeeperMockRecorder
	isgomock struct{}
}

// MockDistrKeeperMockRecorder is the mock recorder for MockDistrKeeper.
type MockDistrKeeperMockRecorder struct {
	mock *MockDistrKeeper
}

// NewMockDistrKeeper creates a new mock instance.
func NewMockDistrKeeper(ctrl *gomock.Controller) *MockDistrKeeper {
	mock := &MockDistrKeeper{ctrl: ctrl}
	mock.recorder = &MockDistrKeeperMockRecorder{mock}
	return mock
}

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

// FundCommunityPool mocks base method.
func (m *MockDistrKeeper) FundCommunityPool(ctx context.Context, amount types0.Coins, sender types0.AccAddress) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FundCommunityPool", ctx, amount, sender)
	ret0, _ := ret[0].(error)
	return ret0
}

// FundCommunityPool indicates an expected call of FundCommunityPool.
func (mr *MockDistrKeeperMockRecorder) FundCommunityPool(ctx, amount, sender any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FundCommunityPool", reflect.TypeOf((*MockDistrKeeper)(nil).FundCommunityPool), ctx, amount, sender)
}

// GetCommunityTax mocks base method.
func (m *MockDistrKeeper) GetCommunityTax(ctx context.Context) (math.LegacyDec, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCommunityTax", ctx)
	ret0, _ := ret[0].(math.LegacyDec)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockTSSKeeper is a mock of TSSKeeper interface.
type MockTSSKeeper struct {
	ctrl     *gomock.Controller
	recorder *MockTSSKeeperMockRecorder
	isgomock struct{}
}

// MockTSSKeeperMockRecorder is the mock recorder for MockTSSKeeper.
type MockTSSKeeperMockRecorder struct {
	mock *MockTSSKeeper
}

// NewMockTSSKeeper creates a new mock instance.
func NewMockTSSKeeper(ctrl *gomock.Controller) *MockTSSKeeper {
	mock := &MockTSSKeeper{ctrl: ctrl}
	mock.recorder = &MockTSSKeeperMockRecorder{mock}
	return mock
}

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

// ActivateMember mocks base method.
func (m *MockTSSKeeper) ActivateMember(ctx types0.Context, groupID tss.GroupID, address types0.AccAddress) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ActivateMember", ctx, groupID, address)
	ret0, _ := ret[0].(error)
	return ret0
}

// ActivateMember indicates an expected call of ActivateMember.
func (mr *MockTSSKeeperMockRecorder) ActivateMember(ctx, groupID, address any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ActivateMember", reflect.TypeOf((*MockTSSKeeper)(nil).ActivateMember), ctx, groupID, address)
}

// CreateGroup mocks base method.
func (m *MockTSSKeeper) CreateGroup(ctx types0.Context, members []types0.AccAddress, threshold uint64, moduleOwner string) (tss.GroupID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateGroup", ctx, members, threshold, moduleOwner)
	ret0, _ := ret[0].(tss.GroupID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateGroup indicates an expected call of CreateGroup.
func (mr *MockTSSKeeperMockRecorder) CreateGroup(ctx, members, threshold, moduleOwner any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGroup", reflect.TypeOf((*MockTSSKeeper)(nil).CreateGroup), ctx, members, threshold, moduleOwner)
}

// DeactivateMember mocks base method.
func (m *MockTSSKeeper) DeactivateMember(ctx types0.Context, groupID tss.GroupID, address types0.AccAddress) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeactivateMember", ctx, groupID, address)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeactivateMember indicates an expected call of DeactivateMember.
func (mr *MockTSSKeeperMockRecorder) DeactivateMember(ctx, groupID, address any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeactivateMember", reflect.TypeOf((*MockTSSKeeper)(nil).DeactivateMember), ctx, groupID, address)
}

// GetDEQueue mocks base method.
func (m *MockTSSKeeper) GetDEQueue(ctx types0.Context, address types0.AccAddress) types.DEQueue {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDEQueue", ctx, address)
	ret0, _ := ret[0].(types.DEQueue)
	return ret0
}

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

// GetGroup mocks base method.
func (m *MockTSSKeeper) GetGroup(ctx types0.Context, groupID tss.GroupID) (types.Group, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetGroup", ctx, groupID)
	ret0, _ := ret[0].(types.Group)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetMemberByAddress mocks base method.
func (m *MockTSSKeeper) GetMemberByAddress(ctx types0.Context, groupID tss.GroupID, address string) (types.Member, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetMemberByAddress", ctx, groupID, address)
	ret0, _ := ret[0].(types.Member)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMemberByAddress indicates an expected call of GetMemberByAddress.
func (mr *MockTSSKeeperMockRecorder) GetMemberByAddress(ctx, groupID, address any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMemberByAddress", reflect.TypeOf((*MockTSSKeeper)(nil).GetMemberByAddress), ctx, groupID, address)
}

// GetSigning mocks base method.
func (m *MockTSSKeeper) GetSigning(ctx types0.Context, signingID tss.SigningID) (types.Signing, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSigning", ctx, signingID)
	ret0, _ := ret[0].(types.Signing)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSigningResult mocks base method.
func (m *MockTSSKeeper) GetSigningResult(ctx types0.Context, signingID tss.SigningID) (*types.SigningResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSigningResult", ctx, signingID)
	ret0, _ := ret[0].(*types.SigningResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MustGetGroup mocks base method.
func (m *MockTSSKeeper) MustGetGroup(ctx types0.Context, groupID tss.GroupID) types.Group {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MustGetGroup", ctx, groupID)
	ret0, _ := ret[0].(types.Group)
	return ret0
}

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

// MustGetMembers mocks base method.
func (m *MockTSSKeeper) MustGetMembers(ctx types0.Context, groupID tss.GroupID) []types.Member {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MustGetMembers", ctx, groupID)
	ret0, _ := ret[0].([]types.Member)
	return ret0
}

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

// MustGetSigning mocks base method.
func (m *MockTSSKeeper) MustGetSigning(ctx types0.Context, signingID tss.SigningID) types.Signing {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MustGetSigning", ctx, signingID)
	ret0, _ := ret[0].(types.Signing)
	return ret0
}

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

// RequestSigning mocks base method.
func (m *MockTSSKeeper) RequestSigning(ctx types0.Context, groupID tss.GroupID, originator types.Originator, content types.Content) (tss.SigningID, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RequestSigning", ctx, groupID, originator, content)
	ret0, _ := ret[0].(tss.SigningID)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RequestSigning indicates an expected call of RequestSigning.
func (mr *MockTSSKeeperMockRecorder) RequestSigning(ctx, groupID, originator, content any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSigning", reflect.TypeOf((*MockTSSKeeper)(nil).RequestSigning), ctx, groupID, originator, content)
}
