// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/erigontech/erigon/cl/abstract (interfaces: BeaconStateMutator)
//
// Generated by this command:
//
//	mockgen -typed=true -destination=./mock_services/beacon_state_mutator_mock.go -package=mock_services . BeaconStateMutator
//

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

import (
	reflect "reflect"

	clparams "github.com/erigontech/erigon/cl/clparams"
	cltypes "github.com/erigontech/erigon/cl/cltypes"
	solid "github.com/erigontech/erigon/cl/cltypes/solid"
	common "github.com/erigontech/erigon/common"
	gomock "go.uber.org/mock/gomock"
)

// MockBeaconStateMutator is a mock of BeaconStateMutator interface.
type MockBeaconStateMutator struct {
	ctrl     *gomock.Controller
	recorder *MockBeaconStateMutatorMockRecorder
	isgomock struct{}
}

// MockBeaconStateMutatorMockRecorder is the mock recorder for MockBeaconStateMutator.
type MockBeaconStateMutatorMockRecorder struct {
	mock *MockBeaconStateMutator
}

// NewMockBeaconStateMutator creates a new mock instance.
func NewMockBeaconStateMutator(ctrl *gomock.Controller) *MockBeaconStateMutator {
	mock := &MockBeaconStateMutator{ctrl: ctrl}
	mock.recorder = &MockBeaconStateMutatorMockRecorder{mock}
	return mock
}

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

// AddCurrentEpochAtteastation mocks base method.
func (m *MockBeaconStateMutator) AddCurrentEpochAtteastation(attestation *solid.PendingAttestation) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddCurrentEpochAtteastation", attestation)
}

// AddCurrentEpochAtteastation indicates an expected call of AddCurrentEpochAtteastation.
func (mr *MockBeaconStateMutatorMockRecorder) AddCurrentEpochAtteastation(attestation any) *MockBeaconStateMutatorAddCurrentEpochAtteastationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCurrentEpochAtteastation", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddCurrentEpochAtteastation), attestation)
	return &MockBeaconStateMutatorAddCurrentEpochAtteastationCall{Call: call}
}

// MockBeaconStateMutatorAddCurrentEpochAtteastationCall wrap *gomock.Call
type MockBeaconStateMutatorAddCurrentEpochAtteastationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddCurrentEpochAtteastationCall) Return() *MockBeaconStateMutatorAddCurrentEpochAtteastationCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddCurrentEpochAtteastationCall) Do(f func(*solid.PendingAttestation)) *MockBeaconStateMutatorAddCurrentEpochAtteastationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddCurrentEpochAtteastationCall) DoAndReturn(f func(*solid.PendingAttestation)) *MockBeaconStateMutatorAddCurrentEpochAtteastationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddCurrentEpochParticipationFlags mocks base method.
func (m *MockBeaconStateMutator) AddCurrentEpochParticipationFlags(flags cltypes.ParticipationFlags) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddCurrentEpochParticipationFlags", flags)
}

// AddCurrentEpochParticipationFlags indicates an expected call of AddCurrentEpochParticipationFlags.
func (mr *MockBeaconStateMutatorMockRecorder) AddCurrentEpochParticipationFlags(flags any) *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCurrentEpochParticipationFlags", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddCurrentEpochParticipationFlags), flags)
	return &MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall{Call: call}
}

// MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall wrap *gomock.Call
type MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall) Return() *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall) Do(f func(cltypes.ParticipationFlags)) *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall) DoAndReturn(f func(cltypes.ParticipationFlags)) *MockBeaconStateMutatorAddCurrentEpochParticipationFlagsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddEth1DataVote mocks base method.
func (m *MockBeaconStateMutator) AddEth1DataVote(vote *cltypes.Eth1Data) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddEth1DataVote", vote)
}

// AddEth1DataVote indicates an expected call of AddEth1DataVote.
func (mr *MockBeaconStateMutatorMockRecorder) AddEth1DataVote(vote any) *MockBeaconStateMutatorAddEth1DataVoteCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddEth1DataVote", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddEth1DataVote), vote)
	return &MockBeaconStateMutatorAddEth1DataVoteCall{Call: call}
}

// MockBeaconStateMutatorAddEth1DataVoteCall wrap *gomock.Call
type MockBeaconStateMutatorAddEth1DataVoteCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddEth1DataVoteCall) Return() *MockBeaconStateMutatorAddEth1DataVoteCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddEth1DataVoteCall) Do(f func(*cltypes.Eth1Data)) *MockBeaconStateMutatorAddEth1DataVoteCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddEth1DataVoteCall) DoAndReturn(f func(*cltypes.Eth1Data)) *MockBeaconStateMutatorAddEth1DataVoteCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddHistoricalRoot mocks base method.
func (m *MockBeaconStateMutator) AddHistoricalRoot(root common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHistoricalRoot", root)
}

// AddHistoricalRoot indicates an expected call of AddHistoricalRoot.
func (mr *MockBeaconStateMutatorMockRecorder) AddHistoricalRoot(root any) *MockBeaconStateMutatorAddHistoricalRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoricalRoot", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddHistoricalRoot), root)
	return &MockBeaconStateMutatorAddHistoricalRootCall{Call: call}
}

// MockBeaconStateMutatorAddHistoricalRootCall wrap *gomock.Call
type MockBeaconStateMutatorAddHistoricalRootCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddHistoricalRootCall) Return() *MockBeaconStateMutatorAddHistoricalRootCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddHistoricalRootCall) Do(f func(common.Hash)) *MockBeaconStateMutatorAddHistoricalRootCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddHistoricalRootCall) DoAndReturn(f func(common.Hash)) *MockBeaconStateMutatorAddHistoricalRootCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddHistoricalSummary mocks base method.
func (m *MockBeaconStateMutator) AddHistoricalSummary(summary *cltypes.HistoricalSummary) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddHistoricalSummary", summary)
}

// AddHistoricalSummary indicates an expected call of AddHistoricalSummary.
func (mr *MockBeaconStateMutatorMockRecorder) AddHistoricalSummary(summary any) *MockBeaconStateMutatorAddHistoricalSummaryCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddHistoricalSummary", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddHistoricalSummary), summary)
	return &MockBeaconStateMutatorAddHistoricalSummaryCall{Call: call}
}

// MockBeaconStateMutatorAddHistoricalSummaryCall wrap *gomock.Call
type MockBeaconStateMutatorAddHistoricalSummaryCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddHistoricalSummaryCall) Return() *MockBeaconStateMutatorAddHistoricalSummaryCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddHistoricalSummaryCall) Do(f func(*cltypes.HistoricalSummary)) *MockBeaconStateMutatorAddHistoricalSummaryCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddHistoricalSummaryCall) DoAndReturn(f func(*cltypes.HistoricalSummary)) *MockBeaconStateMutatorAddHistoricalSummaryCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddInactivityScore mocks base method.
func (m *MockBeaconStateMutator) AddInactivityScore(score uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddInactivityScore", score)
}

// AddInactivityScore indicates an expected call of AddInactivityScore.
func (mr *MockBeaconStateMutatorMockRecorder) AddInactivityScore(score any) *MockBeaconStateMutatorAddInactivityScoreCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInactivityScore", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddInactivityScore), score)
	return &MockBeaconStateMutatorAddInactivityScoreCall{Call: call}
}

// MockBeaconStateMutatorAddInactivityScoreCall wrap *gomock.Call
type MockBeaconStateMutatorAddInactivityScoreCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddInactivityScoreCall) Return() *MockBeaconStateMutatorAddInactivityScoreCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddInactivityScoreCall) Do(f func(uint64)) *MockBeaconStateMutatorAddInactivityScoreCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddInactivityScoreCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorAddInactivityScoreCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddPreviousEpochAttestation mocks base method.
func (m *MockBeaconStateMutator) AddPreviousEpochAttestation(attestation *solid.PendingAttestation) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddPreviousEpochAttestation", attestation)
}

// AddPreviousEpochAttestation indicates an expected call of AddPreviousEpochAttestation.
func (mr *MockBeaconStateMutatorMockRecorder) AddPreviousEpochAttestation(attestation any) *MockBeaconStateMutatorAddPreviousEpochAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPreviousEpochAttestation", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddPreviousEpochAttestation), attestation)
	return &MockBeaconStateMutatorAddPreviousEpochAttestationCall{Call: call}
}

// MockBeaconStateMutatorAddPreviousEpochAttestationCall wrap *gomock.Call
type MockBeaconStateMutatorAddPreviousEpochAttestationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddPreviousEpochAttestationCall) Return() *MockBeaconStateMutatorAddPreviousEpochAttestationCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddPreviousEpochAttestationCall) Do(f func(*solid.PendingAttestation)) *MockBeaconStateMutatorAddPreviousEpochAttestationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddPreviousEpochAttestationCall) DoAndReturn(f func(*solid.PendingAttestation)) *MockBeaconStateMutatorAddPreviousEpochAttestationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddPreviousEpochParticipationAt mocks base method.
func (m *MockBeaconStateMutator) AddPreviousEpochParticipationAt(index int, delta byte) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddPreviousEpochParticipationAt", index, delta)
}

// AddPreviousEpochParticipationAt indicates an expected call of AddPreviousEpochParticipationAt.
func (mr *MockBeaconStateMutatorMockRecorder) AddPreviousEpochParticipationAt(index, delta any) *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPreviousEpochParticipationAt", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddPreviousEpochParticipationAt), index, delta)
	return &MockBeaconStateMutatorAddPreviousEpochParticipationAtCall{Call: call}
}

// MockBeaconStateMutatorAddPreviousEpochParticipationAtCall wrap *gomock.Call
type MockBeaconStateMutatorAddPreviousEpochParticipationAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall) Return() *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall) Do(f func(int, byte)) *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall) DoAndReturn(f func(int, byte)) *MockBeaconStateMutatorAddPreviousEpochParticipationAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddPreviousEpochParticipationFlags mocks base method.
func (m *MockBeaconStateMutator) AddPreviousEpochParticipationFlags(flags cltypes.ParticipationFlags) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddPreviousEpochParticipationFlags", flags)
}

// AddPreviousEpochParticipationFlags indicates an expected call of AddPreviousEpochParticipationFlags.
func (mr *MockBeaconStateMutatorMockRecorder) AddPreviousEpochParticipationFlags(flags any) *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPreviousEpochParticipationFlags", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddPreviousEpochParticipationFlags), flags)
	return &MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall{Call: call}
}

// MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall wrap *gomock.Call
type MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall) Return() *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall) Do(f func(cltypes.ParticipationFlags)) *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall) DoAndReturn(f func(cltypes.ParticipationFlags)) *MockBeaconStateMutatorAddPreviousEpochParticipationFlagsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddValidator mocks base method.
func (m *MockBeaconStateMutator) AddValidator(validator solid.Validator, balance uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddValidator", validator, balance)
}

// AddValidator indicates an expected call of AddValidator.
func (mr *MockBeaconStateMutatorMockRecorder) AddValidator(validator, balance any) *MockBeaconStateMutatorAddValidatorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddValidator", reflect.TypeOf((*MockBeaconStateMutator)(nil).AddValidator), validator, balance)
	return &MockBeaconStateMutatorAddValidatorCall{Call: call}
}

// MockBeaconStateMutatorAddValidatorCall wrap *gomock.Call
type MockBeaconStateMutatorAddValidatorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAddValidatorCall) Return() *MockBeaconStateMutatorAddValidatorCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAddValidatorCall) Do(f func(solid.Validator, uint64)) *MockBeaconStateMutatorAddValidatorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAddValidatorCall) DoAndReturn(f func(solid.Validator, uint64)) *MockBeaconStateMutatorAddValidatorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AppendPendingConsolidation mocks base method.
func (m *MockBeaconStateMutator) AppendPendingConsolidation(consolidation *solid.PendingConsolidation) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendPendingConsolidation", consolidation)
}

// AppendPendingConsolidation indicates an expected call of AppendPendingConsolidation.
func (mr *MockBeaconStateMutatorMockRecorder) AppendPendingConsolidation(consolidation any) *MockBeaconStateMutatorAppendPendingConsolidationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendPendingConsolidation", reflect.TypeOf((*MockBeaconStateMutator)(nil).AppendPendingConsolidation), consolidation)
	return &MockBeaconStateMutatorAppendPendingConsolidationCall{Call: call}
}

// MockBeaconStateMutatorAppendPendingConsolidationCall wrap *gomock.Call
type MockBeaconStateMutatorAppendPendingConsolidationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAppendPendingConsolidationCall) Return() *MockBeaconStateMutatorAppendPendingConsolidationCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAppendPendingConsolidationCall) Do(f func(*solid.PendingConsolidation)) *MockBeaconStateMutatorAppendPendingConsolidationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAppendPendingConsolidationCall) DoAndReturn(f func(*solid.PendingConsolidation)) *MockBeaconStateMutatorAppendPendingConsolidationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AppendPendingDeposit mocks base method.
func (m *MockBeaconStateMutator) AppendPendingDeposit(deposit *solid.PendingDeposit) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendPendingDeposit", deposit)
}

// AppendPendingDeposit indicates an expected call of AppendPendingDeposit.
func (mr *MockBeaconStateMutatorMockRecorder) AppendPendingDeposit(deposit any) *MockBeaconStateMutatorAppendPendingDepositCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendPendingDeposit", reflect.TypeOf((*MockBeaconStateMutator)(nil).AppendPendingDeposit), deposit)
	return &MockBeaconStateMutatorAppendPendingDepositCall{Call: call}
}

// MockBeaconStateMutatorAppendPendingDepositCall wrap *gomock.Call
type MockBeaconStateMutatorAppendPendingDepositCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAppendPendingDepositCall) Return() *MockBeaconStateMutatorAppendPendingDepositCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAppendPendingDepositCall) Do(f func(*solid.PendingDeposit)) *MockBeaconStateMutatorAppendPendingDepositCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAppendPendingDepositCall) DoAndReturn(f func(*solid.PendingDeposit)) *MockBeaconStateMutatorAppendPendingDepositCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AppendPendingPartialWithdrawal mocks base method.
func (m *MockBeaconStateMutator) AppendPendingPartialWithdrawal(withdrawal *solid.PendingPartialWithdrawal) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendPendingPartialWithdrawal", withdrawal)
}

// AppendPendingPartialWithdrawal indicates an expected call of AppendPendingPartialWithdrawal.
func (mr *MockBeaconStateMutatorMockRecorder) AppendPendingPartialWithdrawal(withdrawal any) *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendPendingPartialWithdrawal", reflect.TypeOf((*MockBeaconStateMutator)(nil).AppendPendingPartialWithdrawal), withdrawal)
	return &MockBeaconStateMutatorAppendPendingPartialWithdrawalCall{Call: call}
}

// MockBeaconStateMutatorAppendPendingPartialWithdrawalCall wrap *gomock.Call
type MockBeaconStateMutatorAppendPendingPartialWithdrawalCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall) Return() *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall) Do(f func(*solid.PendingPartialWithdrawal)) *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall) DoAndReturn(f func(*solid.PendingPartialWithdrawal)) *MockBeaconStateMutatorAppendPendingPartialWithdrawalCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AppendValidator mocks base method.
func (m *MockBeaconStateMutator) AppendValidator(in solid.Validator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AppendValidator", in)
}

// AppendValidator indicates an expected call of AppendValidator.
func (mr *MockBeaconStateMutatorMockRecorder) AppendValidator(in any) *MockBeaconStateMutatorAppendValidatorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AppendValidator", reflect.TypeOf((*MockBeaconStateMutator)(nil).AppendValidator), in)
	return &MockBeaconStateMutatorAppendValidatorCall{Call: call}
}

// MockBeaconStateMutatorAppendValidatorCall wrap *gomock.Call
type MockBeaconStateMutatorAppendValidatorCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorAppendValidatorCall) Return() *MockBeaconStateMutatorAppendValidatorCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorAppendValidatorCall) Do(f func(solid.Validator)) *MockBeaconStateMutatorAppendValidatorCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorAppendValidatorCall) DoAndReturn(f func(solid.Validator)) *MockBeaconStateMutatorAppendValidatorCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResetCurrentEpochAttestations indicates an expected call of ResetCurrentEpochAttestations.
func (mr *MockBeaconStateMutatorMockRecorder) ResetCurrentEpochAttestations() *MockBeaconStateMutatorResetCurrentEpochAttestationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetCurrentEpochAttestations", reflect.TypeOf((*MockBeaconStateMutator)(nil).ResetCurrentEpochAttestations))
	return &MockBeaconStateMutatorResetCurrentEpochAttestationsCall{Call: call}
}

// MockBeaconStateMutatorResetCurrentEpochAttestationsCall wrap *gomock.Call
type MockBeaconStateMutatorResetCurrentEpochAttestationsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorResetCurrentEpochAttestationsCall) Return() *MockBeaconStateMutatorResetCurrentEpochAttestationsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorResetCurrentEpochAttestationsCall) Do(f func()) *MockBeaconStateMutatorResetCurrentEpochAttestationsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorResetCurrentEpochAttestationsCall) DoAndReturn(f func()) *MockBeaconStateMutatorResetCurrentEpochAttestationsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResetEpochParticipation indicates an expected call of ResetEpochParticipation.
func (mr *MockBeaconStateMutatorMockRecorder) ResetEpochParticipation() *MockBeaconStateMutatorResetEpochParticipationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEpochParticipation", reflect.TypeOf((*MockBeaconStateMutator)(nil).ResetEpochParticipation))
	return &MockBeaconStateMutatorResetEpochParticipationCall{Call: call}
}

// MockBeaconStateMutatorResetEpochParticipationCall wrap *gomock.Call
type MockBeaconStateMutatorResetEpochParticipationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorResetEpochParticipationCall) Return() *MockBeaconStateMutatorResetEpochParticipationCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorResetEpochParticipationCall) Do(f func()) *MockBeaconStateMutatorResetEpochParticipationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorResetEpochParticipationCall) DoAndReturn(f func()) *MockBeaconStateMutatorResetEpochParticipationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResetEth1DataVotes indicates an expected call of ResetEth1DataVotes.
func (mr *MockBeaconStateMutatorMockRecorder) ResetEth1DataVotes() *MockBeaconStateMutatorResetEth1DataVotesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEth1DataVotes", reflect.TypeOf((*MockBeaconStateMutator)(nil).ResetEth1DataVotes))
	return &MockBeaconStateMutatorResetEth1DataVotesCall{Call: call}
}

// MockBeaconStateMutatorResetEth1DataVotesCall wrap *gomock.Call
type MockBeaconStateMutatorResetEth1DataVotesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorResetEth1DataVotesCall) Return() *MockBeaconStateMutatorResetEth1DataVotesCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorResetEth1DataVotesCall) Do(f func()) *MockBeaconStateMutatorResetEth1DataVotesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorResetEth1DataVotesCall) DoAndReturn(f func()) *MockBeaconStateMutatorResetEth1DataVotesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResetHistoricalSummaries indicates an expected call of ResetHistoricalSummaries.
func (mr *MockBeaconStateMutatorMockRecorder) ResetHistoricalSummaries() *MockBeaconStateMutatorResetHistoricalSummariesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetHistoricalSummaries", reflect.TypeOf((*MockBeaconStateMutator)(nil).ResetHistoricalSummaries))
	return &MockBeaconStateMutatorResetHistoricalSummariesCall{Call: call}
}

// MockBeaconStateMutatorResetHistoricalSummariesCall wrap *gomock.Call
type MockBeaconStateMutatorResetHistoricalSummariesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorResetHistoricalSummariesCall) Return() *MockBeaconStateMutatorResetHistoricalSummariesCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorResetHistoricalSummariesCall) Do(f func()) *MockBeaconStateMutatorResetHistoricalSummariesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorResetHistoricalSummariesCall) DoAndReturn(f func()) *MockBeaconStateMutatorResetHistoricalSummariesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ResetPreviousEpochAttestations indicates an expected call of ResetPreviousEpochAttestations.
func (mr *MockBeaconStateMutatorMockRecorder) ResetPreviousEpochAttestations() *MockBeaconStateMutatorResetPreviousEpochAttestationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetPreviousEpochAttestations", reflect.TypeOf((*MockBeaconStateMutator)(nil).ResetPreviousEpochAttestations))
	return &MockBeaconStateMutatorResetPreviousEpochAttestationsCall{Call: call}
}

// MockBeaconStateMutatorResetPreviousEpochAttestationsCall wrap *gomock.Call
type MockBeaconStateMutatorResetPreviousEpochAttestationsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorResetPreviousEpochAttestationsCall) Return() *MockBeaconStateMutatorResetPreviousEpochAttestationsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorResetPreviousEpochAttestationsCall) Do(f func()) *MockBeaconStateMutatorResetPreviousEpochAttestationsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorResetPreviousEpochAttestationsCall) DoAndReturn(f func()) *MockBeaconStateMutatorResetPreviousEpochAttestationsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetActivationEligibilityEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetActivationEligibilityEpochForValidatorAtIndex(index int, epoch uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetActivationEligibilityEpochForValidatorAtIndex", index, epoch)
}

// SetActivationEligibilityEpochForValidatorAtIndex indicates an expected call of SetActivationEligibilityEpochForValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetActivationEligibilityEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetActivationEligibilityEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetActivationEligibilityEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall) Return() *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall) Do(f func(int, uint64)) *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall) DoAndReturn(f func(int, uint64)) *MockBeaconStateMutatorSetActivationEligibilityEpochForValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetActivationEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetActivationEpochForValidatorAtIndex(index int, epoch uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetActivationEpochForValidatorAtIndex", index, epoch)
}

// SetActivationEpochForValidatorAtIndex indicates an expected call of SetActivationEpochForValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetActivationEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetActivationEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetActivationEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall) Return() *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall) Do(f func(int, uint64)) *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall) DoAndReturn(f func(int, uint64)) *MockBeaconStateMutatorSetActivationEpochForValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetBlockRootAt mocks base method.
func (m *MockBeaconStateMutator) SetBlockRootAt(index int, root common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBlockRootAt", index, root)
}

// SetBlockRootAt indicates an expected call of SetBlockRootAt.
func (mr *MockBeaconStateMutatorMockRecorder) SetBlockRootAt(index, root any) *MockBeaconStateMutatorSetBlockRootAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBlockRootAt", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetBlockRootAt), index, root)
	return &MockBeaconStateMutatorSetBlockRootAtCall{Call: call}
}

// MockBeaconStateMutatorSetBlockRootAtCall wrap *gomock.Call
type MockBeaconStateMutatorSetBlockRootAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetBlockRootAtCall) Return() *MockBeaconStateMutatorSetBlockRootAtCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetBlockRootAtCall) Do(f func(int, common.Hash)) *MockBeaconStateMutatorSetBlockRootAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetBlockRootAtCall) DoAndReturn(f func(int, common.Hash)) *MockBeaconStateMutatorSetBlockRootAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetBuilderPendingPayments mocks base method.
func (m *MockBeaconStateMutator) SetBuilderPendingPayments(arg0 *solid.VectorSSZ[*cltypes.BuilderPendingPayment]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBuilderPendingPayments", arg0)
}

// SetBuilderPendingPayments indicates an expected call of SetBuilderPendingPayments.
func (mr *MockBeaconStateMutatorMockRecorder) SetBuilderPendingPayments(arg0 any) *MockBeaconStateMutatorSetBuilderPendingPaymentsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBuilderPendingPayments", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetBuilderPendingPayments), arg0)
	return &MockBeaconStateMutatorSetBuilderPendingPaymentsCall{Call: call}
}

// MockBeaconStateMutatorSetBuilderPendingPaymentsCall wrap *gomock.Call
type MockBeaconStateMutatorSetBuilderPendingPaymentsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetBuilderPendingPaymentsCall) Return() *MockBeaconStateMutatorSetBuilderPendingPaymentsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetBuilderPendingPaymentsCall) Do(f func(*solid.VectorSSZ[*cltypes.BuilderPendingPayment])) *MockBeaconStateMutatorSetBuilderPendingPaymentsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetBuilderPendingPaymentsCall) DoAndReturn(f func(*solid.VectorSSZ[*cltypes.BuilderPendingPayment])) *MockBeaconStateMutatorSetBuilderPendingPaymentsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetBuilderPendingWithdrawals mocks base method.
func (m *MockBeaconStateMutator) SetBuilderPendingWithdrawals(withdrawals *solid.ListSSZ[*cltypes.BuilderPendingWithdrawal]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBuilderPendingWithdrawals", withdrawals)
}

// SetBuilderPendingWithdrawals indicates an expected call of SetBuilderPendingWithdrawals.
func (mr *MockBeaconStateMutatorMockRecorder) SetBuilderPendingWithdrawals(withdrawals any) *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBuilderPendingWithdrawals", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetBuilderPendingWithdrawals), withdrawals)
	return &MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall{Call: call}
}

// MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall wrap *gomock.Call
type MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall) Return() *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall) Do(f func(*solid.ListSSZ[*cltypes.BuilderPendingWithdrawal])) *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall) DoAndReturn(f func(*solid.ListSSZ[*cltypes.BuilderPendingWithdrawal])) *MockBeaconStateMutatorSetBuilderPendingWithdrawalsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetBuilders mocks base method.
func (m *MockBeaconStateMutator) SetBuilders(builders *solid.ListSSZ[*cltypes.Builder]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetBuilders", builders)
}

// SetBuilders indicates an expected call of SetBuilders.
func (mr *MockBeaconStateMutatorMockRecorder) SetBuilders(builders any) *MockBeaconStateMutatorSetBuildersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBuilders", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetBuilders), builders)
	return &MockBeaconStateMutatorSetBuildersCall{Call: call}
}

// MockBeaconStateMutatorSetBuildersCall wrap *gomock.Call
type MockBeaconStateMutatorSetBuildersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetBuildersCall) Return() *MockBeaconStateMutatorSetBuildersCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetBuildersCall) Do(f func(*solid.ListSSZ[*cltypes.Builder])) *MockBeaconStateMutatorSetBuildersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetBuildersCall) DoAndReturn(f func(*solid.ListSSZ[*cltypes.Builder])) *MockBeaconStateMutatorSetBuildersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetConsolidationBalanceToConsume mocks base method.
func (m *MockBeaconStateMutator) SetConsolidationBalanceToConsume(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetConsolidationBalanceToConsume", arg0)
}

// SetConsolidationBalanceToConsume indicates an expected call of SetConsolidationBalanceToConsume.
func (mr *MockBeaconStateMutatorMockRecorder) SetConsolidationBalanceToConsume(arg0 any) *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConsolidationBalanceToConsume", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetConsolidationBalanceToConsume), arg0)
	return &MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall{Call: call}
}

// MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall wrap *gomock.Call
type MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall) Return() *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall) Do(f func(uint64)) *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetConsolidationBalanceToConsumeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetCurrentEpochParticipationFlags mocks base method.
func (m *MockBeaconStateMutator) SetCurrentEpochParticipationFlags(flags []cltypes.ParticipationFlags) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentEpochParticipationFlags", flags)
}

// SetCurrentEpochParticipationFlags indicates an expected call of SetCurrentEpochParticipationFlags.
func (mr *MockBeaconStateMutatorMockRecorder) SetCurrentEpochParticipationFlags(flags any) *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentEpochParticipationFlags", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetCurrentEpochParticipationFlags), flags)
	return &MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall{Call: call}
}

// MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall wrap *gomock.Call
type MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall) Return() *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall) Do(f func([]cltypes.ParticipationFlags)) *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall) DoAndReturn(f func([]cltypes.ParticipationFlags)) *MockBeaconStateMutatorSetCurrentEpochParticipationFlagsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetCurrentJustifiedCheckpoint mocks base method.
func (m *MockBeaconStateMutator) SetCurrentJustifiedCheckpoint(currentJustifiedCheckpoint solid.Checkpoint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentJustifiedCheckpoint", currentJustifiedCheckpoint)
}

// SetCurrentJustifiedCheckpoint indicates an expected call of SetCurrentJustifiedCheckpoint.
func (mr *MockBeaconStateMutatorMockRecorder) SetCurrentJustifiedCheckpoint(currentJustifiedCheckpoint any) *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentJustifiedCheckpoint", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetCurrentJustifiedCheckpoint), currentJustifiedCheckpoint)
	return &MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall{Call: call}
}

// MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall wrap *gomock.Call
type MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall) Return() *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall) Do(f func(solid.Checkpoint)) *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall) DoAndReturn(f func(solid.Checkpoint)) *MockBeaconStateMutatorSetCurrentJustifiedCheckpointCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetCurrentSyncCommittee mocks base method.
func (m *MockBeaconStateMutator) SetCurrentSyncCommittee(currentSyncCommittee *solid.SyncCommittee) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCurrentSyncCommittee", currentSyncCommittee)
}

// SetCurrentSyncCommittee indicates an expected call of SetCurrentSyncCommittee.
func (mr *MockBeaconStateMutatorMockRecorder) SetCurrentSyncCommittee(currentSyncCommittee any) *MockBeaconStateMutatorSetCurrentSyncCommitteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentSyncCommittee", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetCurrentSyncCommittee), currentSyncCommittee)
	return &MockBeaconStateMutatorSetCurrentSyncCommitteeCall{Call: call}
}

// MockBeaconStateMutatorSetCurrentSyncCommitteeCall wrap *gomock.Call
type MockBeaconStateMutatorSetCurrentSyncCommitteeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetCurrentSyncCommitteeCall) Return() *MockBeaconStateMutatorSetCurrentSyncCommitteeCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetCurrentSyncCommitteeCall) Do(f func(*solid.SyncCommittee)) *MockBeaconStateMutatorSetCurrentSyncCommitteeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetCurrentSyncCommitteeCall) DoAndReturn(f func(*solid.SyncCommittee)) *MockBeaconStateMutatorSetCurrentSyncCommitteeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetDepositBalanceToConsume mocks base method.
func (m *MockBeaconStateMutator) SetDepositBalanceToConsume(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDepositBalanceToConsume", arg0)
}

// SetDepositBalanceToConsume indicates an expected call of SetDepositBalanceToConsume.
func (mr *MockBeaconStateMutatorMockRecorder) SetDepositBalanceToConsume(arg0 any) *MockBeaconStateMutatorSetDepositBalanceToConsumeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDepositBalanceToConsume", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetDepositBalanceToConsume), arg0)
	return &MockBeaconStateMutatorSetDepositBalanceToConsumeCall{Call: call}
}

// MockBeaconStateMutatorSetDepositBalanceToConsumeCall wrap *gomock.Call
type MockBeaconStateMutatorSetDepositBalanceToConsumeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetDepositBalanceToConsumeCall) Return() *MockBeaconStateMutatorSetDepositBalanceToConsumeCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetDepositBalanceToConsumeCall) Do(f func(uint64)) *MockBeaconStateMutatorSetDepositBalanceToConsumeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetDepositBalanceToConsumeCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetDepositBalanceToConsumeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetDepositRequestsStartIndex mocks base method.
func (m *MockBeaconStateMutator) SetDepositRequestsStartIndex(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetDepositRequestsStartIndex", arg0)
}

// SetDepositRequestsStartIndex indicates an expected call of SetDepositRequestsStartIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetDepositRequestsStartIndex(arg0 any) *MockBeaconStateMutatorSetDepositRequestsStartIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDepositRequestsStartIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetDepositRequestsStartIndex), arg0)
	return &MockBeaconStateMutatorSetDepositRequestsStartIndexCall{Call: call}
}

// MockBeaconStateMutatorSetDepositRequestsStartIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetDepositRequestsStartIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetDepositRequestsStartIndexCall) Return() *MockBeaconStateMutatorSetDepositRequestsStartIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetDepositRequestsStartIndexCall) Do(f func(uint64)) *MockBeaconStateMutatorSetDepositRequestsStartIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetDepositRequestsStartIndexCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetDepositRequestsStartIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEarlistConsolidationEpoch mocks base method.
func (m *MockBeaconStateMutator) SetEarlistConsolidationEpoch(arg0 uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEarlistConsolidationEpoch", arg0)
}

// SetEarlistConsolidationEpoch indicates an expected call of SetEarlistConsolidationEpoch.
func (mr *MockBeaconStateMutatorMockRecorder) SetEarlistConsolidationEpoch(arg0 any) *MockBeaconStateMutatorSetEarlistConsolidationEpochCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEarlistConsolidationEpoch", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetEarlistConsolidationEpoch), arg0)
	return &MockBeaconStateMutatorSetEarlistConsolidationEpochCall{Call: call}
}

// MockBeaconStateMutatorSetEarlistConsolidationEpochCall wrap *gomock.Call
type MockBeaconStateMutatorSetEarlistConsolidationEpochCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetEarlistConsolidationEpochCall) Return() *MockBeaconStateMutatorSetEarlistConsolidationEpochCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetEarlistConsolidationEpochCall) Do(f func(uint64)) *MockBeaconStateMutatorSetEarlistConsolidationEpochCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetEarlistConsolidationEpochCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetEarlistConsolidationEpochCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEffectiveBalanceForValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetEffectiveBalanceForValidatorAtIndex(index int, balance uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEffectiveBalanceForValidatorAtIndex", index, balance)
}

// SetEffectiveBalanceForValidatorAtIndex indicates an expected call of SetEffectiveBalanceForValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetEffectiveBalanceForValidatorAtIndex(index, balance any) *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEffectiveBalanceForValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetEffectiveBalanceForValidatorAtIndex), index, balance)
	return &MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall) Return() *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall) Do(f func(int, uint64)) *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall) DoAndReturn(f func(int, uint64)) *MockBeaconStateMutatorSetEffectiveBalanceForValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEpochParticipationForValidatorIndex mocks base method.
func (m *MockBeaconStateMutator) SetEpochParticipationForValidatorIndex(isCurrentEpoch bool, index int, flags cltypes.ParticipationFlags) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEpochParticipationForValidatorIndex", isCurrentEpoch, index, flags)
}

// SetEpochParticipationForValidatorIndex indicates an expected call of SetEpochParticipationForValidatorIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetEpochParticipationForValidatorIndex(isCurrentEpoch, index, flags any) *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEpochParticipationForValidatorIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetEpochParticipationForValidatorIndex), isCurrentEpoch, index, flags)
	return &MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall{Call: call}
}

// MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall) Return() *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall) Do(f func(bool, int, cltypes.ParticipationFlags)) *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall) DoAndReturn(f func(bool, int, cltypes.ParticipationFlags)) *MockBeaconStateMutatorSetEpochParticipationForValidatorIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEth1Data mocks base method.
func (m *MockBeaconStateMutator) SetEth1Data(eth1Data *cltypes.Eth1Data) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEth1Data", eth1Data)
}

// SetEth1Data indicates an expected call of SetEth1Data.
func (mr *MockBeaconStateMutatorMockRecorder) SetEth1Data(eth1Data any) *MockBeaconStateMutatorSetEth1DataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEth1Data", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetEth1Data), eth1Data)
	return &MockBeaconStateMutatorSetEth1DataCall{Call: call}
}

// MockBeaconStateMutatorSetEth1DataCall wrap *gomock.Call
type MockBeaconStateMutatorSetEth1DataCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetEth1DataCall) Return() *MockBeaconStateMutatorSetEth1DataCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetEth1DataCall) Do(f func(*cltypes.Eth1Data)) *MockBeaconStateMutatorSetEth1DataCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetEth1DataCall) DoAndReturn(f func(*cltypes.Eth1Data)) *MockBeaconStateMutatorSetEth1DataCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetEth1DepositIndex mocks base method.
func (m *MockBeaconStateMutator) SetEth1DepositIndex(eth1DepositIndex uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetEth1DepositIndex", eth1DepositIndex)
}

// SetEth1DepositIndex indicates an expected call of SetEth1DepositIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetEth1DepositIndex(eth1DepositIndex any) *MockBeaconStateMutatorSetEth1DepositIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEth1DepositIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetEth1DepositIndex), eth1DepositIndex)
	return &MockBeaconStateMutatorSetEth1DepositIndexCall{Call: call}
}

// MockBeaconStateMutatorSetEth1DepositIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetEth1DepositIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetEth1DepositIndexCall) Return() *MockBeaconStateMutatorSetEth1DepositIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetEth1DepositIndexCall) Do(f func(uint64)) *MockBeaconStateMutatorSetEth1DepositIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetEth1DepositIndexCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetEth1DepositIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetExecutionPayloadAvailability mocks base method.
func (m *MockBeaconStateMutator) SetExecutionPayloadAvailability(slot uint64, available bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExecutionPayloadAvailability", slot, available)
}

// SetExecutionPayloadAvailability indicates an expected call of SetExecutionPayloadAvailability.
func (mr *MockBeaconStateMutatorMockRecorder) SetExecutionPayloadAvailability(slot, available any) *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExecutionPayloadAvailability", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetExecutionPayloadAvailability), slot, available)
	return &MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall{Call: call}
}

// MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall wrap *gomock.Call
type MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall) Return() *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall) Do(f func(uint64, bool)) *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall) DoAndReturn(f func(uint64, bool)) *MockBeaconStateMutatorSetExecutionPayloadAvailabilityCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetExitEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetExitEpochForValidatorAtIndex(index int, epoch uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetExitEpochForValidatorAtIndex", index, epoch)
}

// SetExitEpochForValidatorAtIndex indicates an expected call of SetExitEpochForValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetExitEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExitEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetExitEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall) Return() *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall) Do(f func(int, uint64)) *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall) DoAndReturn(f func(int, uint64)) *MockBeaconStateMutatorSetExitEpochForValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetFinalizedCheckpoint mocks base method.
func (m *MockBeaconStateMutator) SetFinalizedCheckpoint(finalizedCheckpoint solid.Checkpoint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFinalizedCheckpoint", finalizedCheckpoint)
}

// SetFinalizedCheckpoint indicates an expected call of SetFinalizedCheckpoint.
func (mr *MockBeaconStateMutatorMockRecorder) SetFinalizedCheckpoint(finalizedCheckpoint any) *MockBeaconStateMutatorSetFinalizedCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFinalizedCheckpoint", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetFinalizedCheckpoint), finalizedCheckpoint)
	return &MockBeaconStateMutatorSetFinalizedCheckpointCall{Call: call}
}

// MockBeaconStateMutatorSetFinalizedCheckpointCall wrap *gomock.Call
type MockBeaconStateMutatorSetFinalizedCheckpointCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetFinalizedCheckpointCall) Return() *MockBeaconStateMutatorSetFinalizedCheckpointCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetFinalizedCheckpointCall) Do(f func(solid.Checkpoint)) *MockBeaconStateMutatorSetFinalizedCheckpointCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetFinalizedCheckpointCall) DoAndReturn(f func(solid.Checkpoint)) *MockBeaconStateMutatorSetFinalizedCheckpointCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetFork mocks base method.
func (m *MockBeaconStateMutator) SetFork(fork *cltypes.Fork) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFork", fork)
}

// SetFork indicates an expected call of SetFork.
func (mr *MockBeaconStateMutatorMockRecorder) SetFork(fork any) *MockBeaconStateMutatorSetForkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFork", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetFork), fork)
	return &MockBeaconStateMutatorSetForkCall{Call: call}
}

// MockBeaconStateMutatorSetForkCall wrap *gomock.Call
type MockBeaconStateMutatorSetForkCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetForkCall) Return() *MockBeaconStateMutatorSetForkCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetForkCall) Do(f func(*cltypes.Fork)) *MockBeaconStateMutatorSetForkCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetForkCall) DoAndReturn(f func(*cltypes.Fork)) *MockBeaconStateMutatorSetForkCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetInactivityScores mocks base method.
func (m *MockBeaconStateMutator) SetInactivityScores(scores []uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetInactivityScores", scores)
}

// SetInactivityScores indicates an expected call of SetInactivityScores.
func (mr *MockBeaconStateMutatorMockRecorder) SetInactivityScores(scores any) *MockBeaconStateMutatorSetInactivityScoresCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInactivityScores", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetInactivityScores), scores)
	return &MockBeaconStateMutatorSetInactivityScoresCall{Call: call}
}

// MockBeaconStateMutatorSetInactivityScoresCall wrap *gomock.Call
type MockBeaconStateMutatorSetInactivityScoresCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetInactivityScoresCall) Return() *MockBeaconStateMutatorSetInactivityScoresCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetInactivityScoresCall) Do(f func([]uint64)) *MockBeaconStateMutatorSetInactivityScoresCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetInactivityScoresCall) DoAndReturn(f func([]uint64)) *MockBeaconStateMutatorSetInactivityScoresCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetJustificationBits mocks base method.
func (m *MockBeaconStateMutator) SetJustificationBits(justificationBits cltypes.JustificationBits) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetJustificationBits", justificationBits)
}

// SetJustificationBits indicates an expected call of SetJustificationBits.
func (mr *MockBeaconStateMutatorMockRecorder) SetJustificationBits(justificationBits any) *MockBeaconStateMutatorSetJustificationBitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetJustificationBits", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetJustificationBits), justificationBits)
	return &MockBeaconStateMutatorSetJustificationBitsCall{Call: call}
}

// MockBeaconStateMutatorSetJustificationBitsCall wrap *gomock.Call
type MockBeaconStateMutatorSetJustificationBitsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetJustificationBitsCall) Return() *MockBeaconStateMutatorSetJustificationBitsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetJustificationBitsCall) Do(f func(cltypes.JustificationBits)) *MockBeaconStateMutatorSetJustificationBitsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetJustificationBitsCall) DoAndReturn(f func(cltypes.JustificationBits)) *MockBeaconStateMutatorSetJustificationBitsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLatestBlockHash mocks base method.
func (m *MockBeaconStateMutator) SetLatestBlockHash(hash common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLatestBlockHash", hash)
}

// SetLatestBlockHash indicates an expected call of SetLatestBlockHash.
func (mr *MockBeaconStateMutatorMockRecorder) SetLatestBlockHash(hash any) *MockBeaconStateMutatorSetLatestBlockHashCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLatestBlockHash", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetLatestBlockHash), hash)
	return &MockBeaconStateMutatorSetLatestBlockHashCall{Call: call}
}

// MockBeaconStateMutatorSetLatestBlockHashCall wrap *gomock.Call
type MockBeaconStateMutatorSetLatestBlockHashCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetLatestBlockHashCall) Return() *MockBeaconStateMutatorSetLatestBlockHashCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetLatestBlockHashCall) Do(f func(common.Hash)) *MockBeaconStateMutatorSetLatestBlockHashCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetLatestBlockHashCall) DoAndReturn(f func(common.Hash)) *MockBeaconStateMutatorSetLatestBlockHashCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLatestBlockHeader mocks base method.
func (m *MockBeaconStateMutator) SetLatestBlockHeader(header *cltypes.BeaconBlockHeader) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLatestBlockHeader", header)
}

// SetLatestBlockHeader indicates an expected call of SetLatestBlockHeader.
func (mr *MockBeaconStateMutatorMockRecorder) SetLatestBlockHeader(header any) *MockBeaconStateMutatorSetLatestBlockHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLatestBlockHeader", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetLatestBlockHeader), header)
	return &MockBeaconStateMutatorSetLatestBlockHeaderCall{Call: call}
}

// MockBeaconStateMutatorSetLatestBlockHeaderCall wrap *gomock.Call
type MockBeaconStateMutatorSetLatestBlockHeaderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetLatestBlockHeaderCall) Return() *MockBeaconStateMutatorSetLatestBlockHeaderCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetLatestBlockHeaderCall) Do(f func(*cltypes.BeaconBlockHeader)) *MockBeaconStateMutatorSetLatestBlockHeaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetLatestBlockHeaderCall) DoAndReturn(f func(*cltypes.BeaconBlockHeader)) *MockBeaconStateMutatorSetLatestBlockHeaderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLatestExecutionPayloadBid mocks base method.
func (m *MockBeaconStateMutator) SetLatestExecutionPayloadBid(bid *cltypes.ExecutionPayloadBid) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLatestExecutionPayloadBid", bid)
}

// SetLatestExecutionPayloadBid indicates an expected call of SetLatestExecutionPayloadBid.
func (mr *MockBeaconStateMutatorMockRecorder) SetLatestExecutionPayloadBid(bid any) *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLatestExecutionPayloadBid", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetLatestExecutionPayloadBid), bid)
	return &MockBeaconStateMutatorSetLatestExecutionPayloadBidCall{Call: call}
}

// MockBeaconStateMutatorSetLatestExecutionPayloadBidCall wrap *gomock.Call
type MockBeaconStateMutatorSetLatestExecutionPayloadBidCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall) Return() *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall) Do(f func(*cltypes.ExecutionPayloadBid)) *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall) DoAndReturn(f func(*cltypes.ExecutionPayloadBid)) *MockBeaconStateMutatorSetLatestExecutionPayloadBidCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetLatestExecutionPayloadHeader mocks base method.
func (m *MockBeaconStateMutator) SetLatestExecutionPayloadHeader(header *cltypes.Eth1Header) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLatestExecutionPayloadHeader", header)
}

// SetLatestExecutionPayloadHeader indicates an expected call of SetLatestExecutionPayloadHeader.
func (mr *MockBeaconStateMutatorMockRecorder) SetLatestExecutionPayloadHeader(header any) *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLatestExecutionPayloadHeader", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetLatestExecutionPayloadHeader), header)
	return &MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall{Call: call}
}

// MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall wrap *gomock.Call
type MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall) Return() *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall) Do(f func(*cltypes.Eth1Header)) *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall) DoAndReturn(f func(*cltypes.Eth1Header)) *MockBeaconStateMutatorSetLatestExecutionPayloadHeaderCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetNextSyncCommittee mocks base method.
func (m *MockBeaconStateMutator) SetNextSyncCommittee(nextSyncCommittee *solid.SyncCommittee) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNextSyncCommittee", nextSyncCommittee)
}

// SetNextSyncCommittee indicates an expected call of SetNextSyncCommittee.
func (mr *MockBeaconStateMutatorMockRecorder) SetNextSyncCommittee(nextSyncCommittee any) *MockBeaconStateMutatorSetNextSyncCommitteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNextSyncCommittee", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetNextSyncCommittee), nextSyncCommittee)
	return &MockBeaconStateMutatorSetNextSyncCommitteeCall{Call: call}
}

// MockBeaconStateMutatorSetNextSyncCommitteeCall wrap *gomock.Call
type MockBeaconStateMutatorSetNextSyncCommitteeCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetNextSyncCommitteeCall) Return() *MockBeaconStateMutatorSetNextSyncCommitteeCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetNextSyncCommitteeCall) Do(f func(*solid.SyncCommittee)) *MockBeaconStateMutatorSetNextSyncCommitteeCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetNextSyncCommitteeCall) DoAndReturn(f func(*solid.SyncCommittee)) *MockBeaconStateMutatorSetNextSyncCommitteeCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetNextWithdrawalBuilderIndex mocks base method.
func (m *MockBeaconStateMutator) SetNextWithdrawalBuilderIndex(index uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNextWithdrawalBuilderIndex", index)
}

// SetNextWithdrawalBuilderIndex indicates an expected call of SetNextWithdrawalBuilderIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetNextWithdrawalBuilderIndex(index any) *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNextWithdrawalBuilderIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetNextWithdrawalBuilderIndex), index)
	return &MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall{Call: call}
}

// MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall) Return() *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall) Do(f func(uint64)) *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetNextWithdrawalBuilderIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetNextWithdrawalIndex mocks base method.
func (m *MockBeaconStateMutator) SetNextWithdrawalIndex(index uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNextWithdrawalIndex", index)
}

// SetNextWithdrawalIndex indicates an expected call of SetNextWithdrawalIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetNextWithdrawalIndex(index any) *MockBeaconStateMutatorSetNextWithdrawalIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNextWithdrawalIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetNextWithdrawalIndex), index)
	return &MockBeaconStateMutatorSetNextWithdrawalIndexCall{Call: call}
}

// MockBeaconStateMutatorSetNextWithdrawalIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetNextWithdrawalIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetNextWithdrawalIndexCall) Return() *MockBeaconStateMutatorSetNextWithdrawalIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetNextWithdrawalIndexCall) Do(f func(uint64)) *MockBeaconStateMutatorSetNextWithdrawalIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetNextWithdrawalIndexCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetNextWithdrawalIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetNextWithdrawalValidatorIndex mocks base method.
func (m *MockBeaconStateMutator) SetNextWithdrawalValidatorIndex(index uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetNextWithdrawalValidatorIndex", index)
}

// SetNextWithdrawalValidatorIndex indicates an expected call of SetNextWithdrawalValidatorIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetNextWithdrawalValidatorIndex(index any) *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNextWithdrawalValidatorIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetNextWithdrawalValidatorIndex), index)
	return &MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall{Call: call}
}

// MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall) Return() *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall) Do(f func(uint64)) *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetNextWithdrawalValidatorIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPayloadExpectedWithdrawals mocks base method.
func (m *MockBeaconStateMutator) SetPayloadExpectedWithdrawals(withdrawals *solid.ListSSZ[*cltypes.Withdrawal]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPayloadExpectedWithdrawals", withdrawals)
}

// SetPayloadExpectedWithdrawals indicates an expected call of SetPayloadExpectedWithdrawals.
func (mr *MockBeaconStateMutatorMockRecorder) SetPayloadExpectedWithdrawals(withdrawals any) *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPayloadExpectedWithdrawals", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPayloadExpectedWithdrawals), withdrawals)
	return &MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall{Call: call}
}

// MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall wrap *gomock.Call
type MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall) Return() *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall) Do(f func(*solid.ListSSZ[*cltypes.Withdrawal])) *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall) DoAndReturn(f func(*solid.ListSSZ[*cltypes.Withdrawal])) *MockBeaconStateMutatorSetPayloadExpectedWithdrawalsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPendingConsolidations mocks base method.
func (m *MockBeaconStateMutator) SetPendingConsolidations(consolidations *solid.ListSSZ[*solid.PendingConsolidation]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPendingConsolidations", consolidations)
}

// SetPendingConsolidations indicates an expected call of SetPendingConsolidations.
func (mr *MockBeaconStateMutatorMockRecorder) SetPendingConsolidations(consolidations any) *MockBeaconStateMutatorSetPendingConsolidationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPendingConsolidations", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPendingConsolidations), consolidations)
	return &MockBeaconStateMutatorSetPendingConsolidationsCall{Call: call}
}

// MockBeaconStateMutatorSetPendingConsolidationsCall wrap *gomock.Call
type MockBeaconStateMutatorSetPendingConsolidationsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPendingConsolidationsCall) Return() *MockBeaconStateMutatorSetPendingConsolidationsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPendingConsolidationsCall) Do(f func(*solid.ListSSZ[*solid.PendingConsolidation])) *MockBeaconStateMutatorSetPendingConsolidationsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPendingConsolidationsCall) DoAndReturn(f func(*solid.ListSSZ[*solid.PendingConsolidation])) *MockBeaconStateMutatorSetPendingConsolidationsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPendingDeposits mocks base method.
func (m *MockBeaconStateMutator) SetPendingDeposits(arg0 *solid.ListSSZ[*solid.PendingDeposit]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPendingDeposits", arg0)
}

// SetPendingDeposits indicates an expected call of SetPendingDeposits.
func (mr *MockBeaconStateMutatorMockRecorder) SetPendingDeposits(arg0 any) *MockBeaconStateMutatorSetPendingDepositsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPendingDeposits", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPendingDeposits), arg0)
	return &MockBeaconStateMutatorSetPendingDepositsCall{Call: call}
}

// MockBeaconStateMutatorSetPendingDepositsCall wrap *gomock.Call
type MockBeaconStateMutatorSetPendingDepositsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPendingDepositsCall) Return() *MockBeaconStateMutatorSetPendingDepositsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPendingDepositsCall) Do(f func(*solid.ListSSZ[*solid.PendingDeposit])) *MockBeaconStateMutatorSetPendingDepositsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPendingDepositsCall) DoAndReturn(f func(*solid.ListSSZ[*solid.PendingDeposit])) *MockBeaconStateMutatorSetPendingDepositsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPendingPartialWithdrawals mocks base method.
func (m *MockBeaconStateMutator) SetPendingPartialWithdrawals(arg0 *solid.ListSSZ[*solid.PendingPartialWithdrawal]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPendingPartialWithdrawals", arg0)
}

// SetPendingPartialWithdrawals indicates an expected call of SetPendingPartialWithdrawals.
func (mr *MockBeaconStateMutatorMockRecorder) SetPendingPartialWithdrawals(arg0 any) *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPendingPartialWithdrawals", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPendingPartialWithdrawals), arg0)
	return &MockBeaconStateMutatorSetPendingPartialWithdrawalsCall{Call: call}
}

// MockBeaconStateMutatorSetPendingPartialWithdrawalsCall wrap *gomock.Call
type MockBeaconStateMutatorSetPendingPartialWithdrawalsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall) Return() *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall) Do(f func(*solid.ListSSZ[*solid.PendingPartialWithdrawal])) *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall) DoAndReturn(f func(*solid.ListSSZ[*solid.PendingPartialWithdrawal])) *MockBeaconStateMutatorSetPendingPartialWithdrawalsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPreviousEpochAttestations mocks base method.
func (m *MockBeaconStateMutator) SetPreviousEpochAttestations(attestations *solid.ListSSZ[*solid.PendingAttestation]) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPreviousEpochAttestations", attestations)
}

// SetPreviousEpochAttestations indicates an expected call of SetPreviousEpochAttestations.
func (mr *MockBeaconStateMutatorMockRecorder) SetPreviousEpochAttestations(attestations any) *MockBeaconStateMutatorSetPreviousEpochAttestationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreviousEpochAttestations", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPreviousEpochAttestations), attestations)
	return &MockBeaconStateMutatorSetPreviousEpochAttestationsCall{Call: call}
}

// MockBeaconStateMutatorSetPreviousEpochAttestationsCall wrap *gomock.Call
type MockBeaconStateMutatorSetPreviousEpochAttestationsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPreviousEpochAttestationsCall) Return() *MockBeaconStateMutatorSetPreviousEpochAttestationsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPreviousEpochAttestationsCall) Do(f func(*solid.ListSSZ[*solid.PendingAttestation])) *MockBeaconStateMutatorSetPreviousEpochAttestationsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPreviousEpochAttestationsCall) DoAndReturn(f func(*solid.ListSSZ[*solid.PendingAttestation])) *MockBeaconStateMutatorSetPreviousEpochAttestationsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPreviousEpochParticipationFlags mocks base method.
func (m *MockBeaconStateMutator) SetPreviousEpochParticipationFlags(flags []cltypes.ParticipationFlags) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPreviousEpochParticipationFlags", flags)
}

// SetPreviousEpochParticipationFlags indicates an expected call of SetPreviousEpochParticipationFlags.
func (mr *MockBeaconStateMutatorMockRecorder) SetPreviousEpochParticipationFlags(flags any) *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreviousEpochParticipationFlags", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPreviousEpochParticipationFlags), flags)
	return &MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall{Call: call}
}

// MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall wrap *gomock.Call
type MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall) Return() *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall) Do(f func([]cltypes.ParticipationFlags)) *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall) DoAndReturn(f func([]cltypes.ParticipationFlags)) *MockBeaconStateMutatorSetPreviousEpochParticipationFlagsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetPreviousJustifiedCheckpoint mocks base method.
func (m *MockBeaconStateMutator) SetPreviousJustifiedCheckpoint(previousJustifiedCheckpoint solid.Checkpoint) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetPreviousJustifiedCheckpoint", previousJustifiedCheckpoint)
}

// SetPreviousJustifiedCheckpoint indicates an expected call of SetPreviousJustifiedCheckpoint.
func (mr *MockBeaconStateMutatorMockRecorder) SetPreviousJustifiedCheckpoint(previousJustifiedCheckpoint any) *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreviousJustifiedCheckpoint", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetPreviousJustifiedCheckpoint), previousJustifiedCheckpoint)
	return &MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall{Call: call}
}

// MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall wrap *gomock.Call
type MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall) Return() *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall) Do(f func(solid.Checkpoint)) *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall) DoAndReturn(f func(solid.Checkpoint)) *MockBeaconStateMutatorSetPreviousJustifiedCheckpointCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetProposerLookahead mocks base method.
func (m *MockBeaconStateMutator) SetProposerLookahead(proposerLookahead solid.Uint64VectorSSZ) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetProposerLookahead", proposerLookahead)
}

// SetProposerLookahead indicates an expected call of SetProposerLookahead.
func (mr *MockBeaconStateMutatorMockRecorder) SetProposerLookahead(proposerLookahead any) *MockBeaconStateMutatorSetProposerLookaheadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetProposerLookahead", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetProposerLookahead), proposerLookahead)
	return &MockBeaconStateMutatorSetProposerLookaheadCall{Call: call}
}

// MockBeaconStateMutatorSetProposerLookaheadCall wrap *gomock.Call
type MockBeaconStateMutatorSetProposerLookaheadCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetProposerLookaheadCall) Return() *MockBeaconStateMutatorSetProposerLookaheadCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetProposerLookaheadCall) Do(f func(solid.Uint64VectorSSZ)) *MockBeaconStateMutatorSetProposerLookaheadCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetProposerLookaheadCall) DoAndReturn(f func(solid.Uint64VectorSSZ)) *MockBeaconStateMutatorSetProposerLookaheadCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetRandaoMixAt mocks base method.
func (m *MockBeaconStateMutator) SetRandaoMixAt(index int, mix common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRandaoMixAt", index, mix)
}

// SetRandaoMixAt indicates an expected call of SetRandaoMixAt.
func (mr *MockBeaconStateMutatorMockRecorder) SetRandaoMixAt(index, mix any) *MockBeaconStateMutatorSetRandaoMixAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRandaoMixAt", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetRandaoMixAt), index, mix)
	return &MockBeaconStateMutatorSetRandaoMixAtCall{Call: call}
}

// MockBeaconStateMutatorSetRandaoMixAtCall wrap *gomock.Call
type MockBeaconStateMutatorSetRandaoMixAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetRandaoMixAtCall) Return() *MockBeaconStateMutatorSetRandaoMixAtCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetRandaoMixAtCall) Do(f func(int, common.Hash)) *MockBeaconStateMutatorSetRandaoMixAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetRandaoMixAtCall) DoAndReturn(f func(int, common.Hash)) *MockBeaconStateMutatorSetRandaoMixAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSlashingSegmentAt mocks base method.
func (m *MockBeaconStateMutator) SetSlashingSegmentAt(index int, segment uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSlashingSegmentAt", index, segment)
}

// SetSlashingSegmentAt indicates an expected call of SetSlashingSegmentAt.
func (mr *MockBeaconStateMutatorMockRecorder) SetSlashingSegmentAt(index, segment any) *MockBeaconStateMutatorSetSlashingSegmentAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSlashingSegmentAt", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetSlashingSegmentAt), index, segment)
	return &MockBeaconStateMutatorSetSlashingSegmentAtCall{Call: call}
}

// MockBeaconStateMutatorSetSlashingSegmentAtCall wrap *gomock.Call
type MockBeaconStateMutatorSetSlashingSegmentAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetSlashingSegmentAtCall) Return() *MockBeaconStateMutatorSetSlashingSegmentAtCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetSlashingSegmentAtCall) Do(f func(int, uint64)) *MockBeaconStateMutatorSetSlashingSegmentAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetSlashingSegmentAtCall) DoAndReturn(f func(int, uint64)) *MockBeaconStateMutatorSetSlashingSegmentAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetSlot mocks base method.
func (m *MockBeaconStateMutator) SetSlot(slot uint64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSlot", slot)
}

// SetSlot indicates an expected call of SetSlot.
func (mr *MockBeaconStateMutatorMockRecorder) SetSlot(slot any) *MockBeaconStateMutatorSetSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSlot", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetSlot), slot)
	return &MockBeaconStateMutatorSetSlotCall{Call: call}
}

// MockBeaconStateMutatorSetSlotCall wrap *gomock.Call
type MockBeaconStateMutatorSetSlotCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetSlotCall) Return() *MockBeaconStateMutatorSetSlotCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetSlotCall) Do(f func(uint64)) *MockBeaconStateMutatorSetSlotCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetSlotCall) DoAndReturn(f func(uint64)) *MockBeaconStateMutatorSetSlotCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetStateRootAt mocks base method.
func (m *MockBeaconStateMutator) SetStateRootAt(index int, root common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetStateRootAt", index, root)
}

// SetStateRootAt indicates an expected call of SetStateRootAt.
func (mr *MockBeaconStateMutatorMockRecorder) SetStateRootAt(index, root any) *MockBeaconStateMutatorSetStateRootAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStateRootAt", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetStateRootAt), index, root)
	return &MockBeaconStateMutatorSetStateRootAtCall{Call: call}
}

// MockBeaconStateMutatorSetStateRootAtCall wrap *gomock.Call
type MockBeaconStateMutatorSetStateRootAtCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetStateRootAtCall) Return() *MockBeaconStateMutatorSetStateRootAtCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetStateRootAtCall) Do(f func(int, common.Hash)) *MockBeaconStateMutatorSetStateRootAtCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetStateRootAtCall) DoAndReturn(f func(int, common.Hash)) *MockBeaconStateMutatorSetStateRootAtCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetValidatorAtIndex(index int, validator solid.Validator) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetValidatorAtIndex", index, validator)
}

// SetValidatorAtIndex indicates an expected call of SetValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorAtIndex(index, validator any) *MockBeaconStateMutatorSetValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorAtIndex), index, validator)
	return &MockBeaconStateMutatorSetValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorAtIndexCall) Return() *MockBeaconStateMutatorSetValidatorAtIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorAtIndexCall) Do(f func(int, solid.Validator)) *MockBeaconStateMutatorSetValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorAtIndexCall) DoAndReturn(f func(int, solid.Validator)) *MockBeaconStateMutatorSetValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorBalance mocks base method.
func (m *MockBeaconStateMutator) SetValidatorBalance(index int, balance uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorBalance", index, balance)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorBalance indicates an expected call of SetValidatorBalance.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorBalance(index, balance any) *MockBeaconStateMutatorSetValidatorBalanceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorBalance", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorBalance), index, balance)
	return &MockBeaconStateMutatorSetValidatorBalanceCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorBalanceCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorBalanceCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorBalanceCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorBalanceCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorBalanceCall) Do(f func(int, uint64) error) *MockBeaconStateMutatorSetValidatorBalanceCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorBalanceCall) DoAndReturn(f func(int, uint64) error) *MockBeaconStateMutatorSetValidatorBalanceCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorInactivityScore mocks base method.
func (m *MockBeaconStateMutator) SetValidatorInactivityScore(index int, score uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorInactivityScore", index, score)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorInactivityScore indicates an expected call of SetValidatorInactivityScore.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorInactivityScore(index, score any) *MockBeaconStateMutatorSetValidatorInactivityScoreCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorInactivityScore", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorInactivityScore), index, score)
	return &MockBeaconStateMutatorSetValidatorInactivityScoreCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorInactivityScoreCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorInactivityScoreCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorInactivityScoreCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorInactivityScoreCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorInactivityScoreCall) Do(f func(int, uint64) error) *MockBeaconStateMutatorSetValidatorInactivityScoreCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorInactivityScoreCall) DoAndReturn(f func(int, uint64) error) *MockBeaconStateMutatorSetValidatorInactivityScoreCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorIsCurrentMatchingHeadAttester mocks base method.
func (m *MockBeaconStateMutator) SetValidatorIsCurrentMatchingHeadAttester(index int, value bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorIsCurrentMatchingHeadAttester", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorIsCurrentMatchingHeadAttester indicates an expected call of SetValidatorIsCurrentMatchingHeadAttester.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorIsCurrentMatchingHeadAttester(index, value any) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsCurrentMatchingHeadAttester", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorIsCurrentMatchingHeadAttester), index, value)
	return &MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingHeadAttesterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorIsCurrentMatchingSourceAttester mocks base method.
func (m *MockBeaconStateMutator) SetValidatorIsCurrentMatchingSourceAttester(index int, value bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorIsCurrentMatchingSourceAttester", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorIsCurrentMatchingSourceAttester indicates an expected call of SetValidatorIsCurrentMatchingSourceAttester.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorIsCurrentMatchingSourceAttester(index, value any) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsCurrentMatchingSourceAttester", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorIsCurrentMatchingSourceAttester), index, value)
	return &MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingSourceAttesterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorIsCurrentMatchingTargetAttester mocks base method.
func (m *MockBeaconStateMutator) SetValidatorIsCurrentMatchingTargetAttester(index int, value bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorIsCurrentMatchingTargetAttester", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorIsCurrentMatchingTargetAttester indicates an expected call of SetValidatorIsCurrentMatchingTargetAttester.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorIsCurrentMatchingTargetAttester(index, value any) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsCurrentMatchingTargetAttester", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorIsCurrentMatchingTargetAttester), index, value)
	return &MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsCurrentMatchingTargetAttesterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorIsPreviousMatchingHeadAttester mocks base method.
func (m *MockBeaconStateMutator) SetValidatorIsPreviousMatchingHeadAttester(index int, value bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorIsPreviousMatchingHeadAttester", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorIsPreviousMatchingHeadAttester indicates an expected call of SetValidatorIsPreviousMatchingHeadAttester.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorIsPreviousMatchingHeadAttester(index, value any) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsPreviousMatchingHeadAttester", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorIsPreviousMatchingHeadAttester), index, value)
	return &MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingHeadAttesterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorIsPreviousMatchingSourceAttester mocks base method.
func (m *MockBeaconStateMutator) SetValidatorIsPreviousMatchingSourceAttester(index int, value bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorIsPreviousMatchingSourceAttester", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorIsPreviousMatchingSourceAttester indicates an expected call of SetValidatorIsPreviousMatchingSourceAttester.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorIsPreviousMatchingSourceAttester(index, value any) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsPreviousMatchingSourceAttester", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorIsPreviousMatchingSourceAttester), index, value)
	return &MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingSourceAttesterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorIsPreviousMatchingTargetAttester mocks base method.
func (m *MockBeaconStateMutator) SetValidatorIsPreviousMatchingTargetAttester(index int, value bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorIsPreviousMatchingTargetAttester", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorIsPreviousMatchingTargetAttester indicates an expected call of SetValidatorIsPreviousMatchingTargetAttester.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorIsPreviousMatchingTargetAttester(index, value any) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsPreviousMatchingTargetAttester", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorIsPreviousMatchingTargetAttester), index, value)
	return &MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorIsPreviousMatchingTargetAttesterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorMinCurrentInclusionDelayAttestation mocks base method.
func (m *MockBeaconStateMutator) SetValidatorMinCurrentInclusionDelayAttestation(index int, value *solid.PendingAttestation) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorMinCurrentInclusionDelayAttestation", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorMinCurrentInclusionDelayAttestation indicates an expected call of SetValidatorMinCurrentInclusionDelayAttestation.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorMinCurrentInclusionDelayAttestation(index, value any) *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorMinCurrentInclusionDelayAttestation", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorMinCurrentInclusionDelayAttestation), index, value)
	return &MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall) Do(f func(int, *solid.PendingAttestation) error) *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall) DoAndReturn(f func(int, *solid.PendingAttestation) error) *MockBeaconStateMutatorSetValidatorMinCurrentInclusionDelayAttestationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorMinPreviousInclusionDelayAttestation mocks base method.
func (m *MockBeaconStateMutator) SetValidatorMinPreviousInclusionDelayAttestation(index int, value *solid.PendingAttestation) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorMinPreviousInclusionDelayAttestation", index, value)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorMinPreviousInclusionDelayAttestation indicates an expected call of SetValidatorMinPreviousInclusionDelayAttestation.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorMinPreviousInclusionDelayAttestation(index, value any) *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorMinPreviousInclusionDelayAttestation", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorMinPreviousInclusionDelayAttestation), index, value)
	return &MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall) Do(f func(int, *solid.PendingAttestation) error) *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall) DoAndReturn(f func(int, *solid.PendingAttestation) error) *MockBeaconStateMutatorSetValidatorMinPreviousInclusionDelayAttestationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetValidatorSlashed mocks base method.
func (m *MockBeaconStateMutator) SetValidatorSlashed(index int, slashed bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidatorSlashed", index, slashed)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetValidatorSlashed indicates an expected call of SetValidatorSlashed.
func (mr *MockBeaconStateMutatorMockRecorder) SetValidatorSlashed(index, slashed any) *MockBeaconStateMutatorSetValidatorSlashedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorSlashed", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetValidatorSlashed), index, slashed)
	return &MockBeaconStateMutatorSetValidatorSlashedCall{Call: call}
}

// MockBeaconStateMutatorSetValidatorSlashedCall wrap *gomock.Call
type MockBeaconStateMutatorSetValidatorSlashedCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetValidatorSlashedCall) Return(arg0 error) *MockBeaconStateMutatorSetValidatorSlashedCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetValidatorSlashedCall) Do(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorSlashedCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetValidatorSlashedCall) DoAndReturn(f func(int, bool) error) *MockBeaconStateMutatorSetValidatorSlashedCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetVersion mocks base method.
func (m *MockBeaconStateMutator) SetVersion(version clparams.StateVersion) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetVersion", version)
}

// SetVersion indicates an expected call of SetVersion.
func (mr *MockBeaconStateMutatorMockRecorder) SetVersion(version any) *MockBeaconStateMutatorSetVersionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVersion", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetVersion), version)
	return &MockBeaconStateMutatorSetVersionCall{Call: call}
}

// MockBeaconStateMutatorSetVersionCall wrap *gomock.Call
type MockBeaconStateMutatorSetVersionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetVersionCall) Return() *MockBeaconStateMutatorSetVersionCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetVersionCall) Do(f func(clparams.StateVersion)) *MockBeaconStateMutatorSetVersionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetVersionCall) DoAndReturn(f func(clparams.StateVersion)) *MockBeaconStateMutatorSetVersionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetWithdrawableEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetWithdrawableEpochForValidatorAtIndex(index int, epoch uint64) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWithdrawableEpochForValidatorAtIndex", index, epoch)
	ret0, _ := ret[0].(error)
	return ret0
}

// SetWithdrawableEpochForValidatorAtIndex indicates an expected call of SetWithdrawableEpochForValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetWithdrawableEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithdrawableEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetWithdrawableEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall) Return(arg0 error) *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall) Do(f func(int, uint64) error) *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall) DoAndReturn(f func(int, uint64) error) *MockBeaconStateMutatorSetWithdrawableEpochForValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// SetWithdrawalCredentialForValidatorAtIndex mocks base method.
func (m *MockBeaconStateMutator) SetWithdrawalCredentialForValidatorAtIndex(index int, creds common.Hash) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetWithdrawalCredentialForValidatorAtIndex", index, creds)
}

// SetWithdrawalCredentialForValidatorAtIndex indicates an expected call of SetWithdrawalCredentialForValidatorAtIndex.
func (mr *MockBeaconStateMutatorMockRecorder) SetWithdrawalCredentialForValidatorAtIndex(index, creds any) *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithdrawalCredentialForValidatorAtIndex", reflect.TypeOf((*MockBeaconStateMutator)(nil).SetWithdrawalCredentialForValidatorAtIndex), index, creds)
	return &MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall{Call: call}
}

// MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall wrap *gomock.Call
type MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall) Return() *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall) Do(f func(int, common.Hash)) *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall) DoAndReturn(f func(int, common.Hash)) *MockBeaconStateMutatorSetWithdrawalCredentialForValidatorAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
