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

// 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"
	clonable "github.com/erigontech/erigon/common/clonable"
	gomock "go.uber.org/mock/gomock"
)

// MockBeaconState is a mock of BeaconState interface.
type MockBeaconState struct {
	ctrl     *gomock.Controller
	recorder *MockBeaconStateMockRecorder
	isgomock struct{}
}

// MockBeaconStateMockRecorder is the mock recorder for MockBeaconState.
type MockBeaconStateMockRecorder struct {
	mock *MockBeaconState
}

// NewMockBeaconState creates a new mock instance.
func NewMockBeaconState(ctrl *gomock.Controller) *MockBeaconState {
	mock := &MockBeaconState{ctrl: ctrl}
	mock.recorder = &MockBeaconStateMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// AddPreviousEpochParticipationAt mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) AddPreviousEpochParticipationAt(index, delta any) *MockBeaconStateAddPreviousEpochParticipationAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddPreviousEpochParticipationAt", reflect.TypeOf((*MockBeaconState)(nil).AddPreviousEpochParticipationAt), index, delta)
	return &MockBeaconStateAddPreviousEpochParticipationAtCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// AddValidator mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) AddValidator(validator, balance any) *MockBeaconStateAddValidatorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddValidator", reflect.TypeOf((*MockBeaconState)(nil).AddValidator), validator, balance)
	return &MockBeaconStateAddValidatorCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// BaseReward mocks base method.
func (m *MockBeaconState) BaseReward(index uint64) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BaseReward", index)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BaseReward indicates an expected call of BaseReward.
func (mr *MockBeaconStateMockRecorder) BaseReward(index any) *MockBeaconStateBaseRewardCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BaseReward", reflect.TypeOf((*MockBeaconState)(nil).BaseReward), index)
	return &MockBeaconStateBaseRewardCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateBaseRewardCall) Return(arg0 uint64, arg1 error) *MockBeaconStateBaseRewardCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// BaseRewardPerIncrement indicates an expected call of BaseRewardPerIncrement.
func (mr *MockBeaconStateMockRecorder) BaseRewardPerIncrement() *MockBeaconStateBaseRewardPerIncrementCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BaseRewardPerIncrement", reflect.TypeOf((*MockBeaconState)(nil).BaseRewardPerIncrement))
	return &MockBeaconStateBaseRewardPerIncrementCall{Call: call}
}

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

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

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

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

// BeaconConfig mocks base method.
func (m *MockBeaconState) BeaconConfig() *clparams.BeaconChainConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BeaconConfig")
	ret0, _ := ret[0].(*clparams.BeaconChainConfig)
	return ret0
}

// BeaconConfig indicates an expected call of BeaconConfig.
func (mr *MockBeaconStateMockRecorder) BeaconConfig() *MockBeaconStateBeaconConfigCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BeaconConfig", reflect.TypeOf((*MockBeaconState)(nil).BeaconConfig))
	return &MockBeaconStateBeaconConfigCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateBeaconConfigCall) Return(arg0 *clparams.BeaconChainConfig) *MockBeaconStateBeaconConfigCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// BlockRoot mocks base method.
func (m *MockBeaconState) BlockRoot() ([32]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockRoot")
	ret0, _ := ret[0].([32]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BlockRoot indicates an expected call of BlockRoot.
func (mr *MockBeaconStateMockRecorder) BlockRoot() *MockBeaconStateBlockRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockRoot", reflect.TypeOf((*MockBeaconState)(nil).BlockRoot))
	return &MockBeaconStateBlockRootCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateBlockRootCall) Return(arg0 [32]byte, arg1 error) *MockBeaconStateBlockRootCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateBlockRootCall) Do(f func() ([32]byte, error)) *MockBeaconStateBlockRootCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateBlockRootCall) DoAndReturn(f func() ([32]byte, error)) *MockBeaconStateBlockRootCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// BlockRoots mocks base method.
func (m *MockBeaconState) BlockRoots() solid.HashVectorSSZ {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockRoots")
	ret0, _ := ret[0].(solid.HashVectorSSZ)
	return ret0
}

// BlockRoots indicates an expected call of BlockRoots.
func (mr *MockBeaconStateMockRecorder) BlockRoots() *MockBeaconStateBlockRootsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockRoots", reflect.TypeOf((*MockBeaconState)(nil).BlockRoots))
	return &MockBeaconStateBlockRootsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateBlockRootsCall) Return(arg0 solid.HashVectorSSZ) *MockBeaconStateBlockRootsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Clone mocks base method.
func (m *MockBeaconState) Clone() clonable.Clonable {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Clone")
	ret0, _ := ret[0].(clonable.Clonable)
	return ret0
}

// Clone indicates an expected call of Clone.
func (mr *MockBeaconStateMockRecorder) Clone() *MockBeaconStateCloneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clone", reflect.TypeOf((*MockBeaconState)(nil).Clone))
	return &MockBeaconStateCloneCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateCloneCall) Return(arg0 clonable.Clonable) *MockBeaconStateCloneCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// CommitteeCount indicates an expected call of CommitteeCount.
func (mr *MockBeaconStateMockRecorder) CommitteeCount(epoch any) *MockBeaconStateCommitteeCountCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitteeCount", reflect.TypeOf((*MockBeaconState)(nil).CommitteeCount), epoch)
	return &MockBeaconStateCommitteeCountCall{Call: call}
}

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

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

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

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

// ComputeCommittee mocks base method.
func (m *MockBeaconState) ComputeCommittee(indicies []uint64, slot, index, count uint64) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeCommittee", indicies, slot, index, count)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ComputeCommittee indicates an expected call of ComputeCommittee.
func (mr *MockBeaconStateMockRecorder) ComputeCommittee(indicies, slot, index, count any) *MockBeaconStateComputeCommitteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeCommittee", reflect.TypeOf((*MockBeaconState)(nil).ComputeCommittee), indicies, slot, index, count)
	return &MockBeaconStateComputeCommitteeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateComputeCommitteeCall) Return(arg0 []uint64, arg1 error) *MockBeaconStateComputeCommitteeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ComputeExitEpochAndUpdateChurn mocks base method.
func (m *MockBeaconState) ComputeExitEpochAndUpdateChurn(exitBalance uint64) uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeExitEpochAndUpdateChurn", exitBalance)
	ret0, _ := ret[0].(uint64)
	return ret0
}

// ComputeExitEpochAndUpdateChurn indicates an expected call of ComputeExitEpochAndUpdateChurn.
func (mr *MockBeaconStateMockRecorder) ComputeExitEpochAndUpdateChurn(exitBalance any) *MockBeaconStateComputeExitEpochAndUpdateChurnCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeExitEpochAndUpdateChurn", reflect.TypeOf((*MockBeaconState)(nil).ComputeExitEpochAndUpdateChurn), exitBalance)
	return &MockBeaconStateComputeExitEpochAndUpdateChurnCall{Call: call}
}

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

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

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

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

// ComputeNextSyncCommittee mocks base method.
func (m *MockBeaconState) ComputeNextSyncCommittee() (*solid.SyncCommittee, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ComputeNextSyncCommittee")
	ret0, _ := ret[0].(*solid.SyncCommittee)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ComputeNextSyncCommittee indicates an expected call of ComputeNextSyncCommittee.
func (mr *MockBeaconStateMockRecorder) ComputeNextSyncCommittee() *MockBeaconStateComputeNextSyncCommitteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ComputeNextSyncCommittee", reflect.TypeOf((*MockBeaconState)(nil).ComputeNextSyncCommittee))
	return &MockBeaconStateComputeNextSyncCommitteeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateComputeNextSyncCommitteeCall) Return(arg0 *solid.SyncCommittee, arg1 error) *MockBeaconStateComputeNextSyncCommitteeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// CurrentEpochAttestations mocks base method.
func (m *MockBeaconState) CurrentEpochAttestations() *solid.ListSSZ[*solid.PendingAttestation] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentEpochAttestations")
	ret0, _ := ret[0].(*solid.ListSSZ[*solid.PendingAttestation])
	return ret0
}

// CurrentEpochAttestations indicates an expected call of CurrentEpochAttestations.
func (mr *MockBeaconStateMockRecorder) CurrentEpochAttestations() *MockBeaconStateCurrentEpochAttestationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentEpochAttestations", reflect.TypeOf((*MockBeaconState)(nil).CurrentEpochAttestations))
	return &MockBeaconStateCurrentEpochAttestationsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateCurrentEpochAttestationsCall) Return(arg0 *solid.ListSSZ[*solid.PendingAttestation]) *MockBeaconStateCurrentEpochAttestationsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// CurrentEpochAttestationsLength indicates an expected call of CurrentEpochAttestationsLength.
func (mr *MockBeaconStateMockRecorder) CurrentEpochAttestationsLength() *MockBeaconStateCurrentEpochAttestationsLengthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentEpochAttestationsLength", reflect.TypeOf((*MockBeaconState)(nil).CurrentEpochAttestationsLength))
	return &MockBeaconStateCurrentEpochAttestationsLengthCall{Call: call}
}

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

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

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

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

// CurrentJustifiedCheckpoint mocks base method.
func (m *MockBeaconState) CurrentJustifiedCheckpoint() solid.Checkpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentJustifiedCheckpoint")
	ret0, _ := ret[0].(solid.Checkpoint)
	return ret0
}

// CurrentJustifiedCheckpoint indicates an expected call of CurrentJustifiedCheckpoint.
func (mr *MockBeaconStateMockRecorder) CurrentJustifiedCheckpoint() *MockBeaconStateCurrentJustifiedCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentJustifiedCheckpoint", reflect.TypeOf((*MockBeaconState)(nil).CurrentJustifiedCheckpoint))
	return &MockBeaconStateCurrentJustifiedCheckpointCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateCurrentJustifiedCheckpointCall) Return(arg0 solid.Checkpoint) *MockBeaconStateCurrentJustifiedCheckpointCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// CurrentSyncCommittee mocks base method.
func (m *MockBeaconState) CurrentSyncCommittee() *solid.SyncCommittee {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CurrentSyncCommittee")
	ret0, _ := ret[0].(*solid.SyncCommittee)
	return ret0
}

// CurrentSyncCommittee indicates an expected call of CurrentSyncCommittee.
func (mr *MockBeaconStateMockRecorder) CurrentSyncCommittee() *MockBeaconStateCurrentSyncCommitteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CurrentSyncCommittee", reflect.TypeOf((*MockBeaconState)(nil).CurrentSyncCommittee))
	return &MockBeaconStateCurrentSyncCommitteeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateCurrentSyncCommitteeCall) Return(arg0 *solid.SyncCommittee) *MockBeaconStateCurrentSyncCommitteeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// DebugPrint mocks base method.
func (m *MockBeaconState) DebugPrint(prefix string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "DebugPrint", prefix)
}

// DebugPrint indicates an expected call of DebugPrint.
func (mr *MockBeaconStateMockRecorder) DebugPrint(prefix any) *MockBeaconStateDebugPrintCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DebugPrint", reflect.TypeOf((*MockBeaconState)(nil).DebugPrint), prefix)
	return &MockBeaconStateDebugPrintCall{Call: call}
}

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

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

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

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

// DecodeSSZ mocks base method.
func (m *MockBeaconState) DecodeSSZ(buf []byte, version int) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DecodeSSZ", buf, version)
	ret0, _ := ret[0].(error)
	return ret0
}

// DecodeSSZ indicates an expected call of DecodeSSZ.
func (mr *MockBeaconStateMockRecorder) DecodeSSZ(buf, version any) *MockBeaconStateDecodeSSZCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DecodeSSZ", reflect.TypeOf((*MockBeaconState)(nil).DecodeSSZ), buf, version)
	return &MockBeaconStateDecodeSSZCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateDecodeSSZCall) Do(f func([]byte, int) error) *MockBeaconStateDecodeSSZCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateDecodeSSZCall) DoAndReturn(f func([]byte, int) error) *MockBeaconStateDecodeSSZCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EncodeSSZ mocks base method.
func (m *MockBeaconState) EncodeSSZ(buf []byte) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EncodeSSZ", buf)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EncodeSSZ indicates an expected call of EncodeSSZ.
func (mr *MockBeaconStateMockRecorder) EncodeSSZ(buf any) *MockBeaconStateEncodeSSZCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodeSSZ", reflect.TypeOf((*MockBeaconState)(nil).EncodeSSZ), buf)
	return &MockBeaconStateEncodeSSZCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateEncodeSSZCall) Return(arg0 []byte, arg1 error) *MockBeaconStateEncodeSSZCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateEncodeSSZCall) Do(f func([]byte) ([]byte, error)) *MockBeaconStateEncodeSSZCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateEncodeSSZCall) DoAndReturn(f func([]byte) ([]byte, error)) *MockBeaconStateEncodeSSZCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// EncodingSizeSSZ indicates an expected call of EncodingSizeSSZ.
func (mr *MockBeaconStateMockRecorder) EncodingSizeSSZ() *MockBeaconStateEncodingSizeSSZCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EncodingSizeSSZ", reflect.TypeOf((*MockBeaconState)(nil).EncodingSizeSSZ))
	return &MockBeaconStateEncodingSizeSSZCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateEncodingSizeSSZCall) Return(size int) *MockBeaconStateEncodingSizeSSZCall {
	c.Call = c.Call.Return(size)
	return c
}

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

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

// EpochParticipation mocks base method.
func (m *MockBeaconState) EpochParticipation(currentEpoch bool) *solid.ParticipationBitList {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EpochParticipation", currentEpoch)
	ret0, _ := ret[0].(*solid.ParticipationBitList)
	return ret0
}

// EpochParticipation indicates an expected call of EpochParticipation.
func (mr *MockBeaconStateMockRecorder) EpochParticipation(currentEpoch any) *MockBeaconStateEpochParticipationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EpochParticipation", reflect.TypeOf((*MockBeaconState)(nil).EpochParticipation), currentEpoch)
	return &MockBeaconStateEpochParticipationCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateEpochParticipationCall) Return(arg0 *solid.ParticipationBitList) *MockBeaconStateEpochParticipationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateEpochParticipationCall) Do(f func(bool) *solid.ParticipationBitList) *MockBeaconStateEpochParticipationCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateEpochParticipationCall) DoAndReturn(f func(bool) *solid.ParticipationBitList) *MockBeaconStateEpochParticipationCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// EpochParticipationForValidatorIndex mocks base method.
func (m *MockBeaconState) EpochParticipationForValidatorIndex(isCurrentEpoch bool, index int) cltypes.ParticipationFlags {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EpochParticipationForValidatorIndex", isCurrentEpoch, index)
	ret0, _ := ret[0].(cltypes.ParticipationFlags)
	return ret0
}

// EpochParticipationForValidatorIndex indicates an expected call of EpochParticipationForValidatorIndex.
func (mr *MockBeaconStateMockRecorder) EpochParticipationForValidatorIndex(isCurrentEpoch, index any) *MockBeaconStateEpochParticipationForValidatorIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EpochParticipationForValidatorIndex", reflect.TypeOf((*MockBeaconState)(nil).EpochParticipationForValidatorIndex), isCurrentEpoch, index)
	return &MockBeaconStateEpochParticipationForValidatorIndexCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateEpochParticipationForValidatorIndexCall) Return(arg0 cltypes.ParticipationFlags) *MockBeaconStateEpochParticipationForValidatorIndexCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// Eth1Data indicates an expected call of Eth1Data.
func (mr *MockBeaconStateMockRecorder) Eth1Data() *MockBeaconStateEth1DataCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eth1Data", reflect.TypeOf((*MockBeaconState)(nil).Eth1Data))
	return &MockBeaconStateEth1DataCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateEth1DataCall) Return(arg0 *cltypes.Eth1Data) *MockBeaconStateEth1DataCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// Eth1DataVotes mocks base method.
func (m *MockBeaconState) Eth1DataVotes() *solid.ListSSZ[*cltypes.Eth1Data] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Eth1DataVotes")
	ret0, _ := ret[0].(*solid.ListSSZ[*cltypes.Eth1Data])
	return ret0
}

// Eth1DataVotes indicates an expected call of Eth1DataVotes.
func (mr *MockBeaconStateMockRecorder) Eth1DataVotes() *MockBeaconStateEth1DataVotesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eth1DataVotes", reflect.TypeOf((*MockBeaconState)(nil).Eth1DataVotes))
	return &MockBeaconStateEth1DataVotesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateEth1DataVotesCall) Return(arg0 *solid.ListSSZ[*cltypes.Eth1Data]) *MockBeaconStateEth1DataVotesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// Eth1DepositIndex indicates an expected call of Eth1DepositIndex.
func (mr *MockBeaconStateMockRecorder) Eth1DepositIndex() *MockBeaconStateEth1DepositIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Eth1DepositIndex", reflect.TypeOf((*MockBeaconState)(nil).Eth1DepositIndex))
	return &MockBeaconStateEth1DepositIndexCall{Call: call}
}

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

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

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

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

// FinalizedCheckpoint mocks base method.
func (m *MockBeaconState) FinalizedCheckpoint() solid.Checkpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FinalizedCheckpoint")
	ret0, _ := ret[0].(solid.Checkpoint)
	return ret0
}

// FinalizedCheckpoint indicates an expected call of FinalizedCheckpoint.
func (mr *MockBeaconStateMockRecorder) FinalizedCheckpoint() *MockBeaconStateFinalizedCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FinalizedCheckpoint", reflect.TypeOf((*MockBeaconState)(nil).FinalizedCheckpoint))
	return &MockBeaconStateFinalizedCheckpointCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateFinalizedCheckpointCall) Return(arg0 solid.Checkpoint) *MockBeaconStateFinalizedCheckpointCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// ForEachBalance mocks base method.
func (m *MockBeaconState) ForEachBalance(fn func(uint64, int, int) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ForEachBalance", fn)
}

// ForEachBalance indicates an expected call of ForEachBalance.
func (mr *MockBeaconStateMockRecorder) ForEachBalance(fn any) *MockBeaconStateForEachBalanceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForEachBalance", reflect.TypeOf((*MockBeaconState)(nil).ForEachBalance), fn)
	return &MockBeaconStateForEachBalanceCall{Call: call}
}

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

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

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

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

// ForEachSlashingSegment mocks base method.
func (m *MockBeaconState) ForEachSlashingSegment(fn func(int, uint64, int) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ForEachSlashingSegment", fn)
}

// ForEachSlashingSegment indicates an expected call of ForEachSlashingSegment.
func (mr *MockBeaconStateMockRecorder) ForEachSlashingSegment(fn any) *MockBeaconStateForEachSlashingSegmentCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForEachSlashingSegment", reflect.TypeOf((*MockBeaconState)(nil).ForEachSlashingSegment), fn)
	return &MockBeaconStateForEachSlashingSegmentCall{Call: call}
}

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

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

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

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

// ForEachValidator mocks base method.
func (m *MockBeaconState) ForEachValidator(fn func(solid.Validator, int, int) bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ForEachValidator", fn)
}

// ForEachValidator indicates an expected call of ForEachValidator.
func (mr *MockBeaconStateMockRecorder) ForEachValidator(fn any) *MockBeaconStateForEachValidatorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ForEachValidator", reflect.TypeOf((*MockBeaconState)(nil).ForEachValidator), fn)
	return &MockBeaconStateForEachValidatorCall{Call: call}
}

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

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

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

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

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

// Fork indicates an expected call of Fork.
func (mr *MockBeaconStateMockRecorder) Fork() *MockBeaconStateForkCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fork", reflect.TypeOf((*MockBeaconState)(nil).Fork))
	return &MockBeaconStateForkCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateForkCall) Return(arg0 *cltypes.Fork) *MockBeaconStateForkCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// GenesisTime indicates an expected call of GenesisTime.
func (mr *MockBeaconStateMockRecorder) GenesisTime() *MockBeaconStateGenesisTimeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisTime", reflect.TypeOf((*MockBeaconState)(nil).GenesisTime))
	return &MockBeaconStateGenesisTimeCall{Call: call}
}

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

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

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

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

// GenesisValidatorsRoot mocks base method.
func (m *MockBeaconState) GenesisValidatorsRoot() common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenesisValidatorsRoot")
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// GenesisValidatorsRoot indicates an expected call of GenesisValidatorsRoot.
func (mr *MockBeaconStateMockRecorder) GenesisValidatorsRoot() *MockBeaconStateGenesisValidatorsRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenesisValidatorsRoot", reflect.TypeOf((*MockBeaconState)(nil).GenesisValidatorsRoot))
	return &MockBeaconStateGenesisValidatorsRootCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGenesisValidatorsRootCall) Return(arg0 common.Hash) *MockBeaconStateGenesisValidatorsRootCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// GetActiveValidatorsIndices indicates an expected call of GetActiveValidatorsIndices.
func (mr *MockBeaconStateMockRecorder) GetActiveValidatorsIndices(epoch any) *MockBeaconStateGetActiveValidatorsIndicesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetActiveValidatorsIndices", reflect.TypeOf((*MockBeaconState)(nil).GetActiveValidatorsIndices), epoch)
	return &MockBeaconStateGetActiveValidatorsIndicesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetActiveValidatorsIndicesCall) Return(indicies []uint64) *MockBeaconStateGetActiveValidatorsIndicesCall {
	c.Call = c.Call.Return(indicies)
	return c
}

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

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

// GetAttestationParticipationFlagIndicies mocks base method.
func (m *MockBeaconState) GetAttestationParticipationFlagIndicies(data *solid.AttestationData, inclusionDelay uint64, skipAssert bool) ([]uint8, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttestationParticipationFlagIndicies", data, inclusionDelay, skipAssert)
	ret0, _ := ret[0].([]uint8)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAttestationParticipationFlagIndicies indicates an expected call of GetAttestationParticipationFlagIndicies.
func (mr *MockBeaconStateMockRecorder) GetAttestationParticipationFlagIndicies(data, inclusionDelay, skipAssert any) *MockBeaconStateGetAttestationParticipationFlagIndiciesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttestationParticipationFlagIndicies", reflect.TypeOf((*MockBeaconState)(nil).GetAttestationParticipationFlagIndicies), data, inclusionDelay, skipAssert)
	return &MockBeaconStateGetAttestationParticipationFlagIndiciesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetAttestationParticipationFlagIndiciesCall) Return(arg0 []uint8, arg1 error) *MockBeaconStateGetAttestationParticipationFlagIndiciesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateGetAttestationParticipationFlagIndiciesCall) Do(f func(*solid.AttestationData, uint64, bool) ([]uint8, error)) *MockBeaconStateGetAttestationParticipationFlagIndiciesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateGetAttestationParticipationFlagIndiciesCall) DoAndReturn(f func(*solid.AttestationData, uint64, bool) ([]uint8, error)) *MockBeaconStateGetAttestationParticipationFlagIndiciesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetAttestingIndicies mocks base method.
func (m *MockBeaconState) GetAttestingIndicies(attestation *solid.Attestation, checkBitsLength bool) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAttestingIndicies", attestation, checkBitsLength)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAttestingIndicies indicates an expected call of GetAttestingIndicies.
func (mr *MockBeaconStateMockRecorder) GetAttestingIndicies(attestation, checkBitsLength any) *MockBeaconStateGetAttestingIndiciesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAttestingIndicies", reflect.TypeOf((*MockBeaconState)(nil).GetAttestingIndicies), attestation, checkBitsLength)
	return &MockBeaconStateGetAttestingIndiciesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetAttestingIndiciesCall) Return(arg0 []uint64, arg1 error) *MockBeaconStateGetAttestingIndiciesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateGetAttestingIndiciesCall) Do(f func(*solid.Attestation, bool) ([]uint64, error)) *MockBeaconStateGetAttestingIndiciesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateGetAttestingIndiciesCall) DoAndReturn(f func(*solid.Attestation, bool) ([]uint64, error)) *MockBeaconStateGetAttestingIndiciesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetBeaconCommitee mocks base method.
func (m *MockBeaconState) GetBeaconCommitee(slot, committeeIndex uint64) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBeaconCommitee", slot, committeeIndex)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBeaconCommitee indicates an expected call of GetBeaconCommitee.
func (mr *MockBeaconStateMockRecorder) GetBeaconCommitee(slot, committeeIndex any) *MockBeaconStateGetBeaconCommiteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconCommitee", reflect.TypeOf((*MockBeaconState)(nil).GetBeaconCommitee), slot, committeeIndex)
	return &MockBeaconStateGetBeaconCommiteeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetBeaconCommiteeCall) Return(arg0 []uint64, arg1 error) *MockBeaconStateGetBeaconCommiteeCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// GetBeaconProposerIndex indicates an expected call of GetBeaconProposerIndex.
func (mr *MockBeaconStateMockRecorder) GetBeaconProposerIndex() *MockBeaconStateGetBeaconProposerIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconProposerIndex", reflect.TypeOf((*MockBeaconState)(nil).GetBeaconProposerIndex))
	return &MockBeaconStateGetBeaconProposerIndexCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetBeaconProposerIndexCall) Return(arg0 uint64, arg1 error) *MockBeaconStateGetBeaconProposerIndexCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// GetBeaconProposerIndices mocks base method.
func (m *MockBeaconState) GetBeaconProposerIndices(epoch uint64) ([]uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBeaconProposerIndices", epoch)
	ret0, _ := ret[0].([]uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBeaconProposerIndices indicates an expected call of GetBeaconProposerIndices.
func (mr *MockBeaconStateMockRecorder) GetBeaconProposerIndices(epoch any) *MockBeaconStateGetBeaconProposerIndicesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeaconProposerIndices", reflect.TypeOf((*MockBeaconState)(nil).GetBeaconProposerIndices), epoch)
	return &MockBeaconStateGetBeaconProposerIndicesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetBeaconProposerIndicesCall) Return(arg0 []uint64, arg1 error) *MockBeaconStateGetBeaconProposerIndicesCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// GetBlockRootAtSlot mocks base method.
func (m *MockBeaconState) GetBlockRootAtSlot(slot uint64) (common.Hash, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBlockRootAtSlot", slot)
	ret0, _ := ret[0].(common.Hash)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBlockRootAtSlot indicates an expected call of GetBlockRootAtSlot.
func (mr *MockBeaconStateMockRecorder) GetBlockRootAtSlot(slot any) *MockBeaconStateGetBlockRootAtSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBlockRootAtSlot", reflect.TypeOf((*MockBeaconState)(nil).GetBlockRootAtSlot), slot)
	return &MockBeaconStateGetBlockRootAtSlotCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetBlockRootAtSlotCall) Return(arg0 common.Hash, arg1 error) *MockBeaconStateGetBlockRootAtSlotCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateGetBlockRootAtSlotCall) Do(f func(uint64) (common.Hash, error)) *MockBeaconStateGetBlockRootAtSlotCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateGetBlockRootAtSlotCall) DoAndReturn(f func(uint64) (common.Hash, error)) *MockBeaconStateGetBlockRootAtSlotCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetConsolidationBalanceToConsume indicates an expected call of GetConsolidationBalanceToConsume.
func (mr *MockBeaconStateMockRecorder) GetConsolidationBalanceToConsume() *MockBeaconStateGetConsolidationBalanceToConsumeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsolidationBalanceToConsume", reflect.TypeOf((*MockBeaconState)(nil).GetConsolidationBalanceToConsume))
	return &MockBeaconStateGetConsolidationBalanceToConsumeCall{Call: call}
}

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

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

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

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

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

// GetDepositBalanceToConsume indicates an expected call of GetDepositBalanceToConsume.
func (mr *MockBeaconStateMockRecorder) GetDepositBalanceToConsume() *MockBeaconStateGetDepositBalanceToConsumeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDepositBalanceToConsume", reflect.TypeOf((*MockBeaconState)(nil).GetDepositBalanceToConsume))
	return &MockBeaconStateGetDepositBalanceToConsumeCall{Call: call}
}

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

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

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

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

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

// GetDepositRequestsStartIndex indicates an expected call of GetDepositRequestsStartIndex.
func (mr *MockBeaconStateMockRecorder) GetDepositRequestsStartIndex() *MockBeaconStateGetDepositRequestsStartIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDepositRequestsStartIndex", reflect.TypeOf((*MockBeaconState)(nil).GetDepositRequestsStartIndex))
	return &MockBeaconStateGetDepositRequestsStartIndexCall{Call: call}
}

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

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

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

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

// GetDomain mocks base method.
func (m *MockBeaconState) GetDomain(domainType [4]byte, epoch uint64) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDomain", domainType, epoch)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDomain indicates an expected call of GetDomain.
func (mr *MockBeaconStateMockRecorder) GetDomain(domainType, epoch any) *MockBeaconStateGetDomainCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDomain", reflect.TypeOf((*MockBeaconState)(nil).GetDomain), domainType, epoch)
	return &MockBeaconStateGetDomainCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetDomainCall) Return(arg0 []byte, arg1 error) *MockBeaconStateGetDomainCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateGetDomainCall) Do(f func([4]byte, uint64) ([]byte, error)) *MockBeaconStateGetDomainCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateGetDomainCall) DoAndReturn(f func([4]byte, uint64) ([]byte, error)) *MockBeaconStateGetDomainCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// GetEarlistConsolidationEpoch indicates an expected call of GetEarlistConsolidationEpoch.
func (mr *MockBeaconStateMockRecorder) GetEarlistConsolidationEpoch() *MockBeaconStateGetEarlistConsolidationEpochCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEarlistConsolidationEpoch", reflect.TypeOf((*MockBeaconState)(nil).GetEarlistConsolidationEpoch))
	return &MockBeaconStateGetEarlistConsolidationEpochCall{Call: call}
}

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

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

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

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

// GetPendingConsolidations mocks base method.
func (m *MockBeaconState) GetPendingConsolidations() *solid.ListSSZ[*solid.PendingConsolidation] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPendingConsolidations")
	ret0, _ := ret[0].(*solid.ListSSZ[*solid.PendingConsolidation])
	return ret0
}

// GetPendingConsolidations indicates an expected call of GetPendingConsolidations.
func (mr *MockBeaconStateMockRecorder) GetPendingConsolidations() *MockBeaconStateGetPendingConsolidationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingConsolidations", reflect.TypeOf((*MockBeaconState)(nil).GetPendingConsolidations))
	return &MockBeaconStateGetPendingConsolidationsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetPendingConsolidationsCall) Return(arg0 *solid.ListSSZ[*solid.PendingConsolidation]) *MockBeaconStateGetPendingConsolidationsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// GetPendingDeposits mocks base method.
func (m *MockBeaconState) GetPendingDeposits() *solid.ListSSZ[*solid.PendingDeposit] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPendingDeposits")
	ret0, _ := ret[0].(*solid.ListSSZ[*solid.PendingDeposit])
	return ret0
}

// GetPendingDeposits indicates an expected call of GetPendingDeposits.
func (mr *MockBeaconStateMockRecorder) GetPendingDeposits() *MockBeaconStateGetPendingDepositsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingDeposits", reflect.TypeOf((*MockBeaconState)(nil).GetPendingDeposits))
	return &MockBeaconStateGetPendingDepositsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetPendingDepositsCall) Return(arg0 *solid.ListSSZ[*solid.PendingDeposit]) *MockBeaconStateGetPendingDepositsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// GetPendingPartialWithdrawals mocks base method.
func (m *MockBeaconState) GetPendingPartialWithdrawals() *solid.ListSSZ[*solid.PendingPartialWithdrawal] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPendingPartialWithdrawals")
	ret0, _ := ret[0].(*solid.ListSSZ[*solid.PendingPartialWithdrawal])
	return ret0
}

// GetPendingPartialWithdrawals indicates an expected call of GetPendingPartialWithdrawals.
func (mr *MockBeaconStateMockRecorder) GetPendingPartialWithdrawals() *MockBeaconStateGetPendingPartialWithdrawalsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPendingPartialWithdrawals", reflect.TypeOf((*MockBeaconState)(nil).GetPendingPartialWithdrawals))
	return &MockBeaconStateGetPendingPartialWithdrawalsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetPendingPartialWithdrawalsCall) Return(arg0 *solid.ListSSZ[*solid.PendingPartialWithdrawal]) *MockBeaconStateGetPendingPartialWithdrawalsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// GetProposerLookahead mocks base method.
func (m *MockBeaconState) GetProposerLookahead() solid.Uint64VectorSSZ {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProposerLookahead")
	ret0, _ := ret[0].(solid.Uint64VectorSSZ)
	return ret0
}

// GetProposerLookahead indicates an expected call of GetProposerLookahead.
func (mr *MockBeaconStateMockRecorder) GetProposerLookahead() *MockBeaconStateGetProposerLookaheadCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProposerLookahead", reflect.TypeOf((*MockBeaconState)(nil).GetProposerLookahead))
	return &MockBeaconStateGetProposerLookaheadCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetProposerLookaheadCall) Return(arg0 solid.Uint64VectorSSZ) *MockBeaconStateGetProposerLookaheadCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// GetRandaoMix mocks base method.
func (m *MockBeaconState) GetRandaoMix(index int) [32]byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRandaoMix", index)
	ret0, _ := ret[0].([32]byte)
	return ret0
}

// GetRandaoMix indicates an expected call of GetRandaoMix.
func (mr *MockBeaconStateMockRecorder) GetRandaoMix(index any) *MockBeaconStateGetRandaoMixCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRandaoMix", reflect.TypeOf((*MockBeaconState)(nil).GetRandaoMix), index)
	return &MockBeaconStateGetRandaoMixCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetRandaoMixCall) Return(arg0 [32]byte) *MockBeaconStateGetRandaoMixCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateGetRandaoMixCall) Do(f func(int) [32]byte) *MockBeaconStateGetRandaoMixCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateGetRandaoMixCall) DoAndReturn(f func(int) [32]byte) *MockBeaconStateGetRandaoMixCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetRandaoMixes mocks base method.
func (m *MockBeaconState) GetRandaoMixes(epoch uint64) [32]byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRandaoMixes", epoch)
	ret0, _ := ret[0].([32]byte)
	return ret0
}

// GetRandaoMixes indicates an expected call of GetRandaoMixes.
func (mr *MockBeaconStateMockRecorder) GetRandaoMixes(epoch any) *MockBeaconStateGetRandaoMixesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRandaoMixes", reflect.TypeOf((*MockBeaconState)(nil).GetRandaoMixes), epoch)
	return &MockBeaconStateGetRandaoMixesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateGetRandaoMixesCall) Return(arg0 [32]byte) *MockBeaconStateGetRandaoMixesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// GetTotalActiveBalance indicates an expected call of GetTotalActiveBalance.
func (mr *MockBeaconStateMockRecorder) GetTotalActiveBalance() *MockBeaconStateGetTotalActiveBalanceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTotalActiveBalance", reflect.TypeOf((*MockBeaconState)(nil).GetTotalActiveBalance))
	return &MockBeaconStateGetTotalActiveBalanceCall{Call: call}
}

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

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

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

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

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

// GetValidatorActivationChurnLimit indicates an expected call of GetValidatorActivationChurnLimit.
func (mr *MockBeaconStateMockRecorder) GetValidatorActivationChurnLimit() *MockBeaconStateGetValidatorActivationChurnLimitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorActivationChurnLimit", reflect.TypeOf((*MockBeaconState)(nil).GetValidatorActivationChurnLimit))
	return &MockBeaconStateGetValidatorActivationChurnLimitCall{Call: call}
}

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

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

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

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

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

// GetValidatorChurnLimit indicates an expected call of GetValidatorChurnLimit.
func (mr *MockBeaconStateMockRecorder) GetValidatorChurnLimit() *MockBeaconStateGetValidatorChurnLimitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetValidatorChurnLimit", reflect.TypeOf((*MockBeaconState)(nil).GetValidatorChurnLimit))
	return &MockBeaconStateGetValidatorChurnLimitCall{Call: call}
}

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

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

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

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

// HashSSZ mocks base method.
func (m *MockBeaconState) HashSSZ() ([32]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HashSSZ")
	ret0, _ := ret[0].([32]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HashSSZ indicates an expected call of HashSSZ.
func (mr *MockBeaconStateMockRecorder) HashSSZ() *MockBeaconStateHashSSZCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HashSSZ", reflect.TypeOf((*MockBeaconState)(nil).HashSSZ))
	return &MockBeaconStateHashSSZCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateHashSSZCall) Return(out [32]byte, err error) *MockBeaconStateHashSSZCall {
	c.Call = c.Call.Return(out, err)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateHashSSZCall) Do(f func() ([32]byte, error)) *MockBeaconStateHashSSZCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateHashSSZCall) DoAndReturn(f func() ([32]byte, error)) *MockBeaconStateHashSSZCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// InitiateValidatorExit indicates an expected call of InitiateValidatorExit.
func (mr *MockBeaconStateMockRecorder) InitiateValidatorExit(index any) *MockBeaconStateInitiateValidatorExitCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitiateValidatorExit", reflect.TypeOf((*MockBeaconState)(nil).InitiateValidatorExit), index)
	return &MockBeaconStateInitiateValidatorExitCall{Call: call}
}

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

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

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

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

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

// JustificationBits indicates an expected call of JustificationBits.
func (mr *MockBeaconStateMockRecorder) JustificationBits() *MockBeaconStateJustificationBitsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "JustificationBits", reflect.TypeOf((*MockBeaconState)(nil).JustificationBits))
	return &MockBeaconStateJustificationBitsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateJustificationBitsCall) Return(arg0 cltypes.JustificationBits) *MockBeaconStateJustificationBitsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// LatestBlockHeader mocks base method.
func (m *MockBeaconState) LatestBlockHeader() cltypes.BeaconBlockHeader {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LatestBlockHeader")
	ret0, _ := ret[0].(cltypes.BeaconBlockHeader)
	return ret0
}

// LatestBlockHeader indicates an expected call of LatestBlockHeader.
func (mr *MockBeaconStateMockRecorder) LatestBlockHeader() *MockBeaconStateLatestBlockHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestBlockHeader", reflect.TypeOf((*MockBeaconState)(nil).LatestBlockHeader))
	return &MockBeaconStateLatestBlockHeaderCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateLatestBlockHeaderCall) Return(arg0 cltypes.BeaconBlockHeader) *MockBeaconStateLatestBlockHeaderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// LatestExecutionPayloadHeader mocks base method.
func (m *MockBeaconState) LatestExecutionPayloadHeader() *cltypes.Eth1Header {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LatestExecutionPayloadHeader")
	ret0, _ := ret[0].(*cltypes.Eth1Header)
	return ret0
}

// LatestExecutionPayloadHeader indicates an expected call of LatestExecutionPayloadHeader.
func (mr *MockBeaconStateMockRecorder) LatestExecutionPayloadHeader() *MockBeaconStateLatestExecutionPayloadHeaderCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestExecutionPayloadHeader", reflect.TypeOf((*MockBeaconState)(nil).LatestExecutionPayloadHeader))
	return &MockBeaconStateLatestExecutionPayloadHeaderCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateLatestExecutionPayloadHeaderCall) Return(arg0 *cltypes.Eth1Header) *MockBeaconStateLatestExecutionPayloadHeaderCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// NextSyncCommittee mocks base method.
func (m *MockBeaconState) NextSyncCommittee() *solid.SyncCommittee {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NextSyncCommittee")
	ret0, _ := ret[0].(*solid.SyncCommittee)
	return ret0
}

// NextSyncCommittee indicates an expected call of NextSyncCommittee.
func (mr *MockBeaconStateMockRecorder) NextSyncCommittee() *MockBeaconStateNextSyncCommitteeCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextSyncCommittee", reflect.TypeOf((*MockBeaconState)(nil).NextSyncCommittee))
	return &MockBeaconStateNextSyncCommitteeCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateNextSyncCommitteeCall) Return(arg0 *solid.SyncCommittee) *MockBeaconStateNextSyncCommitteeCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// NextWithdrawalIndex indicates an expected call of NextWithdrawalIndex.
func (mr *MockBeaconStateMockRecorder) NextWithdrawalIndex() *MockBeaconStateNextWithdrawalIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextWithdrawalIndex", reflect.TypeOf((*MockBeaconState)(nil).NextWithdrawalIndex))
	return &MockBeaconStateNextWithdrawalIndexCall{Call: call}
}

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

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

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

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

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

// NextWithdrawalValidatorIndex indicates an expected call of NextWithdrawalValidatorIndex.
func (mr *MockBeaconStateMockRecorder) NextWithdrawalValidatorIndex() *MockBeaconStateNextWithdrawalValidatorIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NextWithdrawalValidatorIndex", reflect.TypeOf((*MockBeaconState)(nil).NextWithdrawalValidatorIndex))
	return &MockBeaconStateNextWithdrawalValidatorIndexCall{Call: call}
}

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

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

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

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

// PreviousEpochAttestations mocks base method.
func (m *MockBeaconState) PreviousEpochAttestations() *solid.ListSSZ[*solid.PendingAttestation] {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreviousEpochAttestations")
	ret0, _ := ret[0].(*solid.ListSSZ[*solid.PendingAttestation])
	return ret0
}

// PreviousEpochAttestations indicates an expected call of PreviousEpochAttestations.
func (mr *MockBeaconStateMockRecorder) PreviousEpochAttestations() *MockBeaconStatePreviousEpochAttestationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviousEpochAttestations", reflect.TypeOf((*MockBeaconState)(nil).PreviousEpochAttestations))
	return &MockBeaconStatePreviousEpochAttestationsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStatePreviousEpochAttestationsCall) Return(arg0 *solid.ListSSZ[*solid.PendingAttestation]) *MockBeaconStatePreviousEpochAttestationsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// PreviousEpochAttestationsLength indicates an expected call of PreviousEpochAttestationsLength.
func (mr *MockBeaconStateMockRecorder) PreviousEpochAttestationsLength() *MockBeaconStatePreviousEpochAttestationsLengthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviousEpochAttestationsLength", reflect.TypeOf((*MockBeaconState)(nil).PreviousEpochAttestationsLength))
	return &MockBeaconStatePreviousEpochAttestationsLengthCall{Call: call}
}

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

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

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

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

// PreviousEpochParticipation mocks base method.
func (m *MockBeaconState) PreviousEpochParticipation() *solid.ParticipationBitList {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreviousEpochParticipation")
	ret0, _ := ret[0].(*solid.ParticipationBitList)
	return ret0
}

// PreviousEpochParticipation indicates an expected call of PreviousEpochParticipation.
func (mr *MockBeaconStateMockRecorder) PreviousEpochParticipation() *MockBeaconStatePreviousEpochParticipationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviousEpochParticipation", reflect.TypeOf((*MockBeaconState)(nil).PreviousEpochParticipation))
	return &MockBeaconStatePreviousEpochParticipationCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStatePreviousEpochParticipationCall) Return(arg0 *solid.ParticipationBitList) *MockBeaconStatePreviousEpochParticipationCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// PreviousJustifiedCheckpoint mocks base method.
func (m *MockBeaconState) PreviousJustifiedCheckpoint() solid.Checkpoint {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreviousJustifiedCheckpoint")
	ret0, _ := ret[0].(solid.Checkpoint)
	return ret0
}

// PreviousJustifiedCheckpoint indicates an expected call of PreviousJustifiedCheckpoint.
func (mr *MockBeaconStateMockRecorder) PreviousJustifiedCheckpoint() *MockBeaconStatePreviousJustifiedCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviousJustifiedCheckpoint", reflect.TypeOf((*MockBeaconState)(nil).PreviousJustifiedCheckpoint))
	return &MockBeaconStatePreviousJustifiedCheckpointCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStatePreviousJustifiedCheckpointCall) Return(arg0 solid.Checkpoint) *MockBeaconStatePreviousJustifiedCheckpointCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// PreviousSlot indicates an expected call of PreviousSlot.
func (mr *MockBeaconStateMockRecorder) PreviousSlot() *MockBeaconStatePreviousSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviousSlot", reflect.TypeOf((*MockBeaconState)(nil).PreviousSlot))
	return &MockBeaconStatePreviousSlotCall{Call: call}
}

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

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

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

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

// PreviousStateRoot mocks base method.
func (m *MockBeaconState) PreviousStateRoot() common.Hash {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PreviousStateRoot")
	ret0, _ := ret[0].(common.Hash)
	return ret0
}

// PreviousStateRoot indicates an expected call of PreviousStateRoot.
func (mr *MockBeaconStateMockRecorder) PreviousStateRoot() *MockBeaconStatePreviousStateRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PreviousStateRoot", reflect.TypeOf((*MockBeaconState)(nil).PreviousStateRoot))
	return &MockBeaconStatePreviousStateRootCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStatePreviousStateRootCall) Return(arg0 common.Hash) *MockBeaconStatePreviousStateRootCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// RandaoMixes mocks base method.
func (m *MockBeaconState) RandaoMixes() solid.HashVectorSSZ {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RandaoMixes")
	ret0, _ := ret[0].(solid.HashVectorSSZ)
	return ret0
}

// RandaoMixes indicates an expected call of RandaoMixes.
func (mr *MockBeaconStateMockRecorder) RandaoMixes() *MockBeaconStateRandaoMixesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RandaoMixes", reflect.TypeOf((*MockBeaconState)(nil).RandaoMixes))
	return &MockBeaconStateRandaoMixesCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateRandaoMixesCall) Return(arg0 solid.HashVectorSSZ) *MockBeaconStateRandaoMixesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetActivationEligibilityEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetActivationEligibilityEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateSetActivationEligibilityEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetActivationEligibilityEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetActivationEligibilityEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateSetActivationEligibilityEpochForValidatorAtIndexCall{Call: call}
}

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

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

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

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

// SetActivationEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetActivationEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateSetActivationEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetActivationEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetActivationEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateSetActivationEpochForValidatorAtIndexCall{Call: call}
}

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

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

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

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

// SetBlockRootAt mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetBlockRootAt(index, root any) *MockBeaconStateSetBlockRootAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetBlockRootAt", reflect.TypeOf((*MockBeaconState)(nil).SetBlockRootAt), index, root)
	return &MockBeaconStateSetBlockRootAtCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetEffectiveBalanceForValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetEffectiveBalanceForValidatorAtIndex(index, balance any) *MockBeaconStateSetEffectiveBalanceForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEffectiveBalanceForValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetEffectiveBalanceForValidatorAtIndex), index, balance)
	return &MockBeaconStateSetEffectiveBalanceForValidatorAtIndexCall{Call: call}
}

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

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

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

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

// SetEpochParticipationForValidatorIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetEpochParticipationForValidatorIndex(isCurrentEpoch, index, flags any) *MockBeaconStateSetEpochParticipationForValidatorIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEpochParticipationForValidatorIndex", reflect.TypeOf((*MockBeaconState)(nil).SetEpochParticipationForValidatorIndex), isCurrentEpoch, index, flags)
	return &MockBeaconStateSetEpochParticipationForValidatorIndexCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetExitEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetExitEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateSetExitEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetExitEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetExitEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateSetExitEpochForValidatorAtIndexCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetPendingConsolidations mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetPendingConsolidations(consolidations any) *MockBeaconStateSetPendingConsolidationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPendingConsolidations", reflect.TypeOf((*MockBeaconState)(nil).SetPendingConsolidations), consolidations)
	return &MockBeaconStateSetPendingConsolidationsCall{Call: call}
}

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

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

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

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

// SetPendingDeposits mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetPendingDeposits(arg0 any) *MockBeaconStateSetPendingDepositsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPendingDeposits", reflect.TypeOf((*MockBeaconState)(nil).SetPendingDeposits), arg0)
	return &MockBeaconStateSetPendingDepositsCall{Call: call}
}

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

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

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

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

// SetPendingPartialWithdrawals mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetPendingPartialWithdrawals(arg0 any) *MockBeaconStateSetPendingPartialWithdrawalsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPendingPartialWithdrawals", reflect.TypeOf((*MockBeaconState)(nil).SetPendingPartialWithdrawals), arg0)
	return &MockBeaconStateSetPendingPartialWithdrawalsCall{Call: call}
}

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

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

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

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

// SetPreviousEpochAttestations mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetPreviousEpochAttestations(attestations any) *MockBeaconStateSetPreviousEpochAttestationsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreviousEpochAttestations", reflect.TypeOf((*MockBeaconState)(nil).SetPreviousEpochAttestations), attestations)
	return &MockBeaconStateSetPreviousEpochAttestationsCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetPreviousStateRoot indicates an expected call of SetPreviousStateRoot.
func (mr *MockBeaconStateMockRecorder) SetPreviousStateRoot(root any) *MockBeaconStateSetPreviousStateRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPreviousStateRoot", reflect.TypeOf((*MockBeaconState)(nil).SetPreviousStateRoot), root)
	return &MockBeaconStateSetPreviousStateRootCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// SetRandaoMixAt mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetRandaoMixAt(index, mix any) *MockBeaconStateSetRandaoMixAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRandaoMixAt", reflect.TypeOf((*MockBeaconState)(nil).SetRandaoMixAt), index, mix)
	return &MockBeaconStateSetRandaoMixAtCall{Call: call}
}

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

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

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

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

// SetSlashingSegmentAt mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetSlashingSegmentAt(index, segment any) *MockBeaconStateSetSlashingSegmentAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSlashingSegmentAt", reflect.TypeOf((*MockBeaconState)(nil).SetSlashingSegmentAt), index, segment)
	return &MockBeaconStateSetSlashingSegmentAtCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// SetStateRootAt mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetStateRootAt(index, root any) *MockBeaconStateSetStateRootAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStateRootAt", reflect.TypeOf((*MockBeaconState)(nil).SetStateRootAt), index, root)
	return &MockBeaconStateSetStateRootAtCall{Call: call}
}

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

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

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

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

// SetValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorAtIndex(index, validator any) *MockBeaconStateSetValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorAtIndex), index, validator)
	return &MockBeaconStateSetValidatorAtIndexCall{Call: call}
}

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

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

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

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

// SetValidatorBalance mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorBalance(index, balance any) *MockBeaconStateSetValidatorBalanceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorBalance", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorBalance), index, balance)
	return &MockBeaconStateSetValidatorBalanceCall{Call: call}
}

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

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

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

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

// SetValidatorInactivityScore mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorInactivityScore(index, score any) *MockBeaconStateSetValidatorInactivityScoreCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorInactivityScore", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorInactivityScore), index, score)
	return &MockBeaconStateSetValidatorInactivityScoreCall{Call: call}
}

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

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

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

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

// SetValidatorIsCurrentMatchingHeadAttester mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorIsCurrentMatchingHeadAttester(index, value any) *MockBeaconStateSetValidatorIsCurrentMatchingHeadAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsCurrentMatchingHeadAttester", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorIsCurrentMatchingHeadAttester), index, value)
	return &MockBeaconStateSetValidatorIsCurrentMatchingHeadAttesterCall{Call: call}
}

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

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

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

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

// SetValidatorIsCurrentMatchingSourceAttester mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorIsCurrentMatchingSourceAttester(index, value any) *MockBeaconStateSetValidatorIsCurrentMatchingSourceAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsCurrentMatchingSourceAttester", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorIsCurrentMatchingSourceAttester), index, value)
	return &MockBeaconStateSetValidatorIsCurrentMatchingSourceAttesterCall{Call: call}
}

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

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

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

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

// SetValidatorIsCurrentMatchingTargetAttester mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorIsCurrentMatchingTargetAttester(index, value any) *MockBeaconStateSetValidatorIsCurrentMatchingTargetAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsCurrentMatchingTargetAttester", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorIsCurrentMatchingTargetAttester), index, value)
	return &MockBeaconStateSetValidatorIsCurrentMatchingTargetAttesterCall{Call: call}
}

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

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

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

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

// SetValidatorIsPreviousMatchingHeadAttester mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorIsPreviousMatchingHeadAttester(index, value any) *MockBeaconStateSetValidatorIsPreviousMatchingHeadAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsPreviousMatchingHeadAttester", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorIsPreviousMatchingHeadAttester), index, value)
	return &MockBeaconStateSetValidatorIsPreviousMatchingHeadAttesterCall{Call: call}
}

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

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

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

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

// SetValidatorIsPreviousMatchingSourceAttester mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorIsPreviousMatchingSourceAttester(index, value any) *MockBeaconStateSetValidatorIsPreviousMatchingSourceAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsPreviousMatchingSourceAttester", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorIsPreviousMatchingSourceAttester), index, value)
	return &MockBeaconStateSetValidatorIsPreviousMatchingSourceAttesterCall{Call: call}
}

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

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

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

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

// SetValidatorIsPreviousMatchingTargetAttester mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorIsPreviousMatchingTargetAttester(index, value any) *MockBeaconStateSetValidatorIsPreviousMatchingTargetAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorIsPreviousMatchingTargetAttester", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorIsPreviousMatchingTargetAttester), index, value)
	return &MockBeaconStateSetValidatorIsPreviousMatchingTargetAttesterCall{Call: call}
}

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

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

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

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

// SetValidatorMinCurrentInclusionDelayAttestation mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorMinCurrentInclusionDelayAttestation(index, value any) *MockBeaconStateSetValidatorMinCurrentInclusionDelayAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorMinCurrentInclusionDelayAttestation", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorMinCurrentInclusionDelayAttestation), index, value)
	return &MockBeaconStateSetValidatorMinCurrentInclusionDelayAttestationCall{Call: call}
}

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

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

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

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

// SetValidatorMinPreviousInclusionDelayAttestation mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorMinPreviousInclusionDelayAttestation(index, value any) *MockBeaconStateSetValidatorMinPreviousInclusionDelayAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorMinPreviousInclusionDelayAttestation", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorMinPreviousInclusionDelayAttestation), index, value)
	return &MockBeaconStateSetValidatorMinPreviousInclusionDelayAttestationCall{Call: call}
}

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

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

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

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

// SetValidatorSlashed mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetValidatorSlashed(index, slashed any) *MockBeaconStateSetValidatorSlashedCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidatorSlashed", reflect.TypeOf((*MockBeaconState)(nil).SetValidatorSlashed), index, slashed)
	return &MockBeaconStateSetValidatorSlashedCall{Call: call}
}

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

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

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

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

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

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

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

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

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

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

// SetWithdrawableEpochForValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetWithdrawableEpochForValidatorAtIndex(index, epoch any) *MockBeaconStateSetWithdrawableEpochForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithdrawableEpochForValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetWithdrawableEpochForValidatorAtIndex), index, epoch)
	return &MockBeaconStateSetWithdrawableEpochForValidatorAtIndexCall{Call: call}
}

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

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

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

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

// SetWithdrawalCredentialForValidatorAtIndex mocks base method.
func (m *MockBeaconState) 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 *MockBeaconStateMockRecorder) SetWithdrawalCredentialForValidatorAtIndex(index, creds any) *MockBeaconStateSetWithdrawalCredentialForValidatorAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWithdrawalCredentialForValidatorAtIndex", reflect.TypeOf((*MockBeaconState)(nil).SetWithdrawalCredentialForValidatorAtIndex), index, creds)
	return &MockBeaconStateSetWithdrawalCredentialForValidatorAtIndexCall{Call: call}
}

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

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

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

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

// SlashValidator mocks base method.
func (m *MockBeaconState) SlashValidator(slashedInd uint64, whistleblowerInd *uint64) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlashValidator", slashedInd, whistleblowerInd)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SlashValidator indicates an expected call of SlashValidator.
func (mr *MockBeaconStateMockRecorder) SlashValidator(slashedInd, whistleblowerInd any) *MockBeaconStateSlashValidatorCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlashValidator", reflect.TypeOf((*MockBeaconState)(nil).SlashValidator), slashedInd, whistleblowerInd)
	return &MockBeaconStateSlashValidatorCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateSlashValidatorCall) Return(arg0 uint64, arg1 error) *MockBeaconStateSlashValidatorCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// SlashingSegmentAt mocks base method.
func (m *MockBeaconState) SlashingSegmentAt(pos int) uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SlashingSegmentAt", pos)
	ret0, _ := ret[0].(uint64)
	return ret0
}

// SlashingSegmentAt indicates an expected call of SlashingSegmentAt.
func (mr *MockBeaconStateMockRecorder) SlashingSegmentAt(pos any) *MockBeaconStateSlashingSegmentAtCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SlashingSegmentAt", reflect.TypeOf((*MockBeaconState)(nil).SlashingSegmentAt), pos)
	return &MockBeaconStateSlashingSegmentAtCall{Call: call}
}

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

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

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

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

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

// Slot indicates an expected call of Slot.
func (mr *MockBeaconStateMockRecorder) Slot() *MockBeaconStateSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Slot", reflect.TypeOf((*MockBeaconState)(nil).Slot))
	return &MockBeaconStateSlotCall{Call: call}
}

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

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

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

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

// StateRoots mocks base method.
func (m *MockBeaconState) StateRoots() solid.HashVectorSSZ {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StateRoots")
	ret0, _ := ret[0].(solid.HashVectorSSZ)
	return ret0
}

// StateRoots indicates an expected call of StateRoots.
func (mr *MockBeaconStateMockRecorder) StateRoots() *MockBeaconStateStateRootsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateRoots", reflect.TypeOf((*MockBeaconState)(nil).StateRoots))
	return &MockBeaconStateStateRootsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateStateRootsCall) Return(arg0 solid.HashVectorSSZ) *MockBeaconStateStateRootsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

// SyncRewards mocks base method.
func (m *MockBeaconState) SyncRewards() (uint64, uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SyncRewards")
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(uint64)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// SyncRewards indicates an expected call of SyncRewards.
func (mr *MockBeaconStateMockRecorder) SyncRewards() *MockBeaconStateSyncRewardsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncRewards", reflect.TypeOf((*MockBeaconState)(nil).SyncRewards))
	return &MockBeaconStateSyncRewardsCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateSyncRewardsCall) Return(proposerReward, participantReward uint64, err error) *MockBeaconStateSyncRewardsCall {
	c.Call = c.Call.Return(proposerReward, participantReward, err)
	return c
}

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

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

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

// UpgradeToAltair indicates an expected call of UpgradeToAltair.
func (mr *MockBeaconStateMockRecorder) UpgradeToAltair() *MockBeaconStateUpgradeToAltairCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeToAltair", reflect.TypeOf((*MockBeaconState)(nil).UpgradeToAltair))
	return &MockBeaconStateUpgradeToAltairCall{Call: call}
}

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

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

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

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

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

// UpgradeToBellatrix indicates an expected call of UpgradeToBellatrix.
func (mr *MockBeaconStateMockRecorder) UpgradeToBellatrix() *MockBeaconStateUpgradeToBellatrixCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeToBellatrix", reflect.TypeOf((*MockBeaconState)(nil).UpgradeToBellatrix))
	return &MockBeaconStateUpgradeToBellatrixCall{Call: call}
}

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

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

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

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

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

// UpgradeToCapella indicates an expected call of UpgradeToCapella.
func (mr *MockBeaconStateMockRecorder) UpgradeToCapella() *MockBeaconStateUpgradeToCapellaCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeToCapella", reflect.TypeOf((*MockBeaconState)(nil).UpgradeToCapella))
	return &MockBeaconStateUpgradeToCapellaCall{Call: call}
}

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

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

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

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

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

// UpgradeToDeneb indicates an expected call of UpgradeToDeneb.
func (mr *MockBeaconStateMockRecorder) UpgradeToDeneb() *MockBeaconStateUpgradeToDenebCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeToDeneb", reflect.TypeOf((*MockBeaconState)(nil).UpgradeToDeneb))
	return &MockBeaconStateUpgradeToDenebCall{Call: call}
}

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

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

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

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

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

// UpgradeToElectra indicates an expected call of UpgradeToElectra.
func (mr *MockBeaconStateMockRecorder) UpgradeToElectra() *MockBeaconStateUpgradeToElectraCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeToElectra", reflect.TypeOf((*MockBeaconState)(nil).UpgradeToElectra))
	return &MockBeaconStateUpgradeToElectraCall{Call: call}
}

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

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

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

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

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

// UpgradeToFulu indicates an expected call of UpgradeToFulu.
func (mr *MockBeaconStateMockRecorder) UpgradeToFulu() *MockBeaconStateUpgradeToFuluCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpgradeToFulu", reflect.TypeOf((*MockBeaconState)(nil).UpgradeToFulu))
	return &MockBeaconStateUpgradeToFuluCall{Call: call}
}

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

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

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

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

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

// ValidatorBalance indicates an expected call of ValidatorBalance.
func (mr *MockBeaconStateMockRecorder) ValidatorBalance(index any) *MockBeaconStateValidatorBalanceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorBalance", reflect.TypeOf((*MockBeaconState)(nil).ValidatorBalance), index)
	return &MockBeaconStateValidatorBalanceCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorBalanceCall) Return(arg0 uint64, arg1 error) *MockBeaconStateValidatorBalanceCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// ValidatorEffectiveBalance indicates an expected call of ValidatorEffectiveBalance.
func (mr *MockBeaconStateMockRecorder) ValidatorEffectiveBalance(index any) *MockBeaconStateValidatorEffectiveBalanceCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorEffectiveBalance", reflect.TypeOf((*MockBeaconState)(nil).ValidatorEffectiveBalance), index)
	return &MockBeaconStateValidatorEffectiveBalanceCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorEffectiveBalanceCall) Return(arg0 uint64, arg1 error) *MockBeaconStateValidatorEffectiveBalanceCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// ValidatorExitEpoch indicates an expected call of ValidatorExitEpoch.
func (mr *MockBeaconStateMockRecorder) ValidatorExitEpoch(index any) *MockBeaconStateValidatorExitEpochCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorExitEpoch", reflect.TypeOf((*MockBeaconState)(nil).ValidatorExitEpoch), index)
	return &MockBeaconStateValidatorExitEpochCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorExitEpochCall) Return(arg0 uint64, arg1 error) *MockBeaconStateValidatorExitEpochCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorForValidatorIndex mocks base method.
func (m *MockBeaconState) ValidatorForValidatorIndex(index int) (solid.Validator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorForValidatorIndex", index)
	ret0, _ := ret[0].(solid.Validator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorForValidatorIndex indicates an expected call of ValidatorForValidatorIndex.
func (mr *MockBeaconStateMockRecorder) ValidatorForValidatorIndex(index any) *MockBeaconStateValidatorForValidatorIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorForValidatorIndex", reflect.TypeOf((*MockBeaconState)(nil).ValidatorForValidatorIndex), index)
	return &MockBeaconStateValidatorForValidatorIndexCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorForValidatorIndexCall) Return(arg0 solid.Validator, arg1 error) *MockBeaconStateValidatorForValidatorIndexCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// ValidatorInactivityScore indicates an expected call of ValidatorInactivityScore.
func (mr *MockBeaconStateMockRecorder) ValidatorInactivityScore(index any) *MockBeaconStateValidatorInactivityScoreCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorInactivityScore", reflect.TypeOf((*MockBeaconState)(nil).ValidatorInactivityScore), index)
	return &MockBeaconStateValidatorInactivityScoreCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorInactivityScoreCall) Return(arg0 uint64, arg1 error) *MockBeaconStateValidatorInactivityScoreCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorIndexByPubkey mocks base method.
func (m *MockBeaconState) ValidatorIndexByPubkey(key [48]byte) (uint64, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIndexByPubkey", key)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// ValidatorIndexByPubkey indicates an expected call of ValidatorIndexByPubkey.
func (mr *MockBeaconStateMockRecorder) ValidatorIndexByPubkey(key any) *MockBeaconStateValidatorIndexByPubkeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIndexByPubkey", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIndexByPubkey), key)
	return &MockBeaconStateValidatorIndexByPubkeyCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIndexByPubkeyCall) Return(arg0 uint64, arg1 bool) *MockBeaconStateValidatorIndexByPubkeyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockBeaconStateValidatorIndexByPubkeyCall) Do(f func([48]byte) (uint64, bool)) *MockBeaconStateValidatorIndexByPubkeyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockBeaconStateValidatorIndexByPubkeyCall) DoAndReturn(f func([48]byte) (uint64, bool)) *MockBeaconStateValidatorIndexByPubkeyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ValidatorIsCurrentMatchingHeadAttester mocks base method.
func (m *MockBeaconState) ValidatorIsCurrentMatchingHeadAttester(idx int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIsCurrentMatchingHeadAttester", idx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorIsCurrentMatchingHeadAttester indicates an expected call of ValidatorIsCurrentMatchingHeadAttester.
func (mr *MockBeaconStateMockRecorder) ValidatorIsCurrentMatchingHeadAttester(idx any) *MockBeaconStateValidatorIsCurrentMatchingHeadAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIsCurrentMatchingHeadAttester", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIsCurrentMatchingHeadAttester), idx)
	return &MockBeaconStateValidatorIsCurrentMatchingHeadAttesterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIsCurrentMatchingHeadAttesterCall) Return(arg0 bool, arg1 error) *MockBeaconStateValidatorIsCurrentMatchingHeadAttesterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorIsCurrentMatchingSourceAttester mocks base method.
func (m *MockBeaconState) ValidatorIsCurrentMatchingSourceAttester(idx int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIsCurrentMatchingSourceAttester", idx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorIsCurrentMatchingSourceAttester indicates an expected call of ValidatorIsCurrentMatchingSourceAttester.
func (mr *MockBeaconStateMockRecorder) ValidatorIsCurrentMatchingSourceAttester(idx any) *MockBeaconStateValidatorIsCurrentMatchingSourceAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIsCurrentMatchingSourceAttester", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIsCurrentMatchingSourceAttester), idx)
	return &MockBeaconStateValidatorIsCurrentMatchingSourceAttesterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIsCurrentMatchingSourceAttesterCall) Return(arg0 bool, arg1 error) *MockBeaconStateValidatorIsCurrentMatchingSourceAttesterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorIsCurrentMatchingTargetAttester mocks base method.
func (m *MockBeaconState) ValidatorIsCurrentMatchingTargetAttester(idx int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIsCurrentMatchingTargetAttester", idx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorIsCurrentMatchingTargetAttester indicates an expected call of ValidatorIsCurrentMatchingTargetAttester.
func (mr *MockBeaconStateMockRecorder) ValidatorIsCurrentMatchingTargetAttester(idx any) *MockBeaconStateValidatorIsCurrentMatchingTargetAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIsCurrentMatchingTargetAttester", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIsCurrentMatchingTargetAttester), idx)
	return &MockBeaconStateValidatorIsCurrentMatchingTargetAttesterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIsCurrentMatchingTargetAttesterCall) Return(arg0 bool, arg1 error) *MockBeaconStateValidatorIsCurrentMatchingTargetAttesterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorIsPreviousMatchingHeadAttester mocks base method.
func (m *MockBeaconState) ValidatorIsPreviousMatchingHeadAttester(idx int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIsPreviousMatchingHeadAttester", idx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorIsPreviousMatchingHeadAttester indicates an expected call of ValidatorIsPreviousMatchingHeadAttester.
func (mr *MockBeaconStateMockRecorder) ValidatorIsPreviousMatchingHeadAttester(idx any) *MockBeaconStateValidatorIsPreviousMatchingHeadAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIsPreviousMatchingHeadAttester", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIsPreviousMatchingHeadAttester), idx)
	return &MockBeaconStateValidatorIsPreviousMatchingHeadAttesterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIsPreviousMatchingHeadAttesterCall) Return(arg0 bool, arg1 error) *MockBeaconStateValidatorIsPreviousMatchingHeadAttesterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorIsPreviousMatchingSourceAttester mocks base method.
func (m *MockBeaconState) ValidatorIsPreviousMatchingSourceAttester(idx int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIsPreviousMatchingSourceAttester", idx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorIsPreviousMatchingSourceAttester indicates an expected call of ValidatorIsPreviousMatchingSourceAttester.
func (mr *MockBeaconStateMockRecorder) ValidatorIsPreviousMatchingSourceAttester(idx any) *MockBeaconStateValidatorIsPreviousMatchingSourceAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIsPreviousMatchingSourceAttester", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIsPreviousMatchingSourceAttester), idx)
	return &MockBeaconStateValidatorIsPreviousMatchingSourceAttesterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIsPreviousMatchingSourceAttesterCall) Return(arg0 bool, arg1 error) *MockBeaconStateValidatorIsPreviousMatchingSourceAttesterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// ValidatorIsPreviousMatchingTargetAttester mocks base method.
func (m *MockBeaconState) ValidatorIsPreviousMatchingTargetAttester(idx int) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIsPreviousMatchingTargetAttester", idx)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorIsPreviousMatchingTargetAttester indicates an expected call of ValidatorIsPreviousMatchingTargetAttester.
func (mr *MockBeaconStateMockRecorder) ValidatorIsPreviousMatchingTargetAttester(idx any) *MockBeaconStateValidatorIsPreviousMatchingTargetAttesterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIsPreviousMatchingTargetAttester", reflect.TypeOf((*MockBeaconState)(nil).ValidatorIsPreviousMatchingTargetAttester), idx)
	return &MockBeaconStateValidatorIsPreviousMatchingTargetAttesterCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorIsPreviousMatchingTargetAttesterCall) Return(arg0 bool, arg1 error) *MockBeaconStateValidatorIsPreviousMatchingTargetAttesterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// ValidatorLength indicates an expected call of ValidatorLength.
func (mr *MockBeaconStateMockRecorder) ValidatorLength() *MockBeaconStateValidatorLengthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorLength", reflect.TypeOf((*MockBeaconState)(nil).ValidatorLength))
	return &MockBeaconStateValidatorLengthCall{Call: call}
}

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

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

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

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

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

// ValidatorMinCurrentInclusionDelayAttestation indicates an expected call of ValidatorMinCurrentInclusionDelayAttestation.
func (mr *MockBeaconStateMockRecorder) ValidatorMinCurrentInclusionDelayAttestation(index any) *MockBeaconStateValidatorMinCurrentInclusionDelayAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorMinCurrentInclusionDelayAttestation", reflect.TypeOf((*MockBeaconState)(nil).ValidatorMinCurrentInclusionDelayAttestation), index)
	return &MockBeaconStateValidatorMinCurrentInclusionDelayAttestationCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorMinCurrentInclusionDelayAttestationCall) Return(arg0 *solid.PendingAttestation, arg1 error) *MockBeaconStateValidatorMinCurrentInclusionDelayAttestationCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// ValidatorMinPreviousInclusionDelayAttestation indicates an expected call of ValidatorMinPreviousInclusionDelayAttestation.
func (mr *MockBeaconStateMockRecorder) ValidatorMinPreviousInclusionDelayAttestation(index any) *MockBeaconStateValidatorMinPreviousInclusionDelayAttestationCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorMinPreviousInclusionDelayAttestation", reflect.TypeOf((*MockBeaconState)(nil).ValidatorMinPreviousInclusionDelayAttestation), index)
	return &MockBeaconStateValidatorMinPreviousInclusionDelayAttestationCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorMinPreviousInclusionDelayAttestationCall) Return(arg0 *solid.PendingAttestation, arg1 error) *MockBeaconStateValidatorMinPreviousInclusionDelayAttestationCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

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

// ValidatorSet indicates an expected call of ValidatorSet.
func (mr *MockBeaconStateMockRecorder) ValidatorSet() *MockBeaconStateValidatorSetCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorSet", reflect.TypeOf((*MockBeaconState)(nil).ValidatorSet))
	return &MockBeaconStateValidatorSetCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorSetCall) Return(arg0 *solid.ValidatorSet) *MockBeaconStateValidatorSetCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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

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

// ValidatorWithdrawableEpoch indicates an expected call of ValidatorWithdrawableEpoch.
func (mr *MockBeaconStateMockRecorder) ValidatorWithdrawableEpoch(index any) *MockBeaconStateValidatorWithdrawableEpochCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorWithdrawableEpoch", reflect.TypeOf((*MockBeaconState)(nil).ValidatorWithdrawableEpoch), index)
	return &MockBeaconStateValidatorWithdrawableEpochCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateValidatorWithdrawableEpochCall) Return(arg0 uint64, arg1 error) *MockBeaconStateValidatorWithdrawableEpochCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

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

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

// Version mocks base method.
func (m *MockBeaconState) Version() clparams.StateVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Version")
	ret0, _ := ret[0].(clparams.StateVersion)
	return ret0
}

// Version indicates an expected call of Version.
func (mr *MockBeaconStateMockRecorder) Version() *MockBeaconStateVersionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockBeaconState)(nil).Version))
	return &MockBeaconStateVersionCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockBeaconStateVersionCall) Return(arg0 clparams.StateVersion) *MockBeaconStateVersionCall {
	c.Call = c.Call.Return(arg0)
	return c
}

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

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