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

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

import (
	reflect "reflect"

	synced_data "github.com/erigontech/erigon/cl/beacon/synced_data"
	cltypes "github.com/erigontech/erigon/cl/cltypes"
	state "github.com/erigontech/erigon/cl/phase1/core/state"
	common "github.com/erigontech/erigon/common"
	gomock "go.uber.org/mock/gomock"
)

// MockSyncedData is a mock of SyncedData interface.
type MockSyncedData struct {
	ctrl     *gomock.Controller
	recorder *MockSyncedDataMockRecorder
	isgomock struct{}
}

// MockSyncedDataMockRecorder is the mock recorder for MockSyncedData.
type MockSyncedDataMockRecorder struct {
	mock *MockSyncedData
}

// NewMockSyncedData creates a new mock instance.
func NewMockSyncedData(ctrl *gomock.Controller) *MockSyncedData {
	mock := &MockSyncedData{ctrl: ctrl}
	mock.recorder = &MockSyncedDataMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// HeadRoot indicates an expected call of HeadRoot.
func (mr *MockSyncedDataMockRecorder) HeadRoot() *MockSyncedDataHeadRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadRoot", reflect.TypeOf((*MockSyncedData)(nil).HeadRoot))
	return &MockSyncedDataHeadRootCall{Call: call}
}

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

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

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

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

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

// HeadSlot indicates an expected call of HeadSlot.
func (mr *MockSyncedDataMockRecorder) HeadSlot() *MockSyncedDataHeadSlotCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadSlot", reflect.TypeOf((*MockSyncedData)(nil).HeadSlot))
	return &MockSyncedDataHeadSlotCall{Call: call}
}

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

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

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

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

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

// HistoricalRootElementAtIndex indicates an expected call of HistoricalRootElementAtIndex.
func (mr *MockSyncedDataMockRecorder) HistoricalRootElementAtIndex(index any) *MockSyncedDataHistoricalRootElementAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HistoricalRootElementAtIndex", reflect.TypeOf((*MockSyncedData)(nil).HistoricalRootElementAtIndex), index)
	return &MockSyncedDataHistoricalRootElementAtIndexCall{Call: call}
}

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

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

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

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

// HistoricalSummaryElementAtIndex mocks base method.
func (m *MockSyncedData) HistoricalSummaryElementAtIndex(index int) (*cltypes.HistoricalSummary, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HistoricalSummaryElementAtIndex", index)
	ret0, _ := ret[0].(*cltypes.HistoricalSummary)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HistoricalSummaryElementAtIndex indicates an expected call of HistoricalSummaryElementAtIndex.
func (mr *MockSyncedDataMockRecorder) HistoricalSummaryElementAtIndex(index any) *MockSyncedDataHistoricalSummaryElementAtIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HistoricalSummaryElementAtIndex", reflect.TypeOf((*MockSyncedData)(nil).HistoricalSummaryElementAtIndex), index)
	return &MockSyncedDataHistoricalSummaryElementAtIndexCall{Call: call}
}

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

// Return rewrite *gomock.Call.Return
func (c *MockSyncedDataHistoricalSummaryElementAtIndexCall) Return(arg0 *cltypes.HistoricalSummary, arg1 error) *MockSyncedDataHistoricalSummaryElementAtIndexCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockSyncedDataHistoricalSummaryElementAtIndexCall) Do(f func(int) (*cltypes.HistoricalSummary, error)) *MockSyncedDataHistoricalSummaryElementAtIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSyncedDataHistoricalSummaryElementAtIndexCall) DoAndReturn(f func(int) (*cltypes.HistoricalSummary, error)) *MockSyncedDataHistoricalSummaryElementAtIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OnHeadState mocks base method.
func (m *MockSyncedData) OnHeadState(newState *state.CachingBeaconState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnHeadState", newState)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnHeadState indicates an expected call of OnHeadState.
func (mr *MockSyncedDataMockRecorder) OnHeadState(newState any) *MockSyncedDataOnHeadStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnHeadState", reflect.TypeOf((*MockSyncedData)(nil).OnHeadState), newState)
	return &MockSyncedDataOnHeadStateCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSyncedDataOnHeadStateCall) Do(f func(*state.CachingBeaconState) error) *MockSyncedDataOnHeadStateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSyncedDataOnHeadStateCall) DoAndReturn(f func(*state.CachingBeaconState) error) *MockSyncedDataOnHeadStateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// OnHeadStateWithBlockRoot mocks base method.
func (m *MockSyncedData) OnHeadStateWithBlockRoot(newState *state.CachingBeaconState, blockRoot common.Hash) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnHeadStateWithBlockRoot", newState, blockRoot)
	ret0, _ := ret[0].(error)
	return ret0
}

// OnHeadStateWithBlockRoot indicates an expected call of OnHeadStateWithBlockRoot.
func (mr *MockSyncedDataMockRecorder) OnHeadStateWithBlockRoot(newState, blockRoot any) *MockSyncedDataOnHeadStateWithBlockRootCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnHeadStateWithBlockRoot", reflect.TypeOf((*MockSyncedData)(nil).OnHeadStateWithBlockRoot), newState, blockRoot)
	return &MockSyncedDataOnHeadStateWithBlockRootCall{Call: call}
}

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

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

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

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

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

// Syncing indicates an expected call of Syncing.
func (mr *MockSyncedDataMockRecorder) Syncing() *MockSyncedDataSyncingCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Syncing", reflect.TypeOf((*MockSyncedData)(nil).Syncing))
	return &MockSyncedDataSyncingCall{Call: call}
}

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

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

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

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

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

// UnsetHeadState indicates an expected call of UnsetHeadState.
func (mr *MockSyncedDataMockRecorder) UnsetHeadState() *MockSyncedDataUnsetHeadStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnsetHeadState", reflect.TypeOf((*MockSyncedData)(nil).UnsetHeadState))
	return &MockSyncedDataUnsetHeadStateCall{Call: call}
}

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

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

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

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

// ValidatorIndexByPublicKey mocks base method.
func (m *MockSyncedData) ValidatorIndexByPublicKey(pubkey common.Bytes48) (uint64, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorIndexByPublicKey", pubkey)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ValidatorIndexByPublicKey indicates an expected call of ValidatorIndexByPublicKey.
func (mr *MockSyncedDataMockRecorder) ValidatorIndexByPublicKey(pubkey any) *MockSyncedDataValidatorIndexByPublicKeyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorIndexByPublicKey", reflect.TypeOf((*MockSyncedData)(nil).ValidatorIndexByPublicKey), pubkey)
	return &MockSyncedDataValidatorIndexByPublicKeyCall{Call: call}
}

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

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

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

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

// ValidatorPublicKeyByIndex mocks base method.
func (m *MockSyncedData) ValidatorPublicKeyByIndex(index int) (common.Bytes48, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidatorPublicKeyByIndex", index)
	ret0, _ := ret[0].(common.Bytes48)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ValidatorPublicKeyByIndex indicates an expected call of ValidatorPublicKeyByIndex.
func (mr *MockSyncedDataMockRecorder) ValidatorPublicKeyByIndex(index any) *MockSyncedDataValidatorPublicKeyByIndexCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidatorPublicKeyByIndex", reflect.TypeOf((*MockSyncedData)(nil).ValidatorPublicKeyByIndex), index)
	return &MockSyncedDataValidatorPublicKeyByIndexCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSyncedDataValidatorPublicKeyByIndexCall) Do(f func(int) (common.Bytes48, error)) *MockSyncedDataValidatorPublicKeyByIndexCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSyncedDataValidatorPublicKeyByIndexCall) DoAndReturn(f func(int) (common.Bytes48, error)) *MockSyncedDataValidatorPublicKeyByIndexCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ViewHeadState mocks base method.
func (m *MockSyncedData) ViewHeadState(fn synced_data.ViewHeadStateFn) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ViewHeadState", fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ViewHeadState indicates an expected call of ViewHeadState.
func (mr *MockSyncedDataMockRecorder) ViewHeadState(fn any) *MockSyncedDataViewHeadStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewHeadState", reflect.TypeOf((*MockSyncedData)(nil).ViewHeadState), fn)
	return &MockSyncedDataViewHeadStateCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSyncedDataViewHeadStateCall) Do(f func(synced_data.ViewHeadStateFn) error) *MockSyncedDataViewHeadStateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSyncedDataViewHeadStateCall) DoAndReturn(f func(synced_data.ViewHeadStateFn) error) *MockSyncedDataViewHeadStateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ViewPreviousHeadState mocks base method.
func (m *MockSyncedData) ViewPreviousHeadState(fn synced_data.ViewHeadStateFn) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ViewPreviousHeadState", fn)
	ret0, _ := ret[0].(error)
	return ret0
}

// ViewPreviousHeadState indicates an expected call of ViewPreviousHeadState.
func (mr *MockSyncedDataMockRecorder) ViewPreviousHeadState(fn any) *MockSyncedDataViewPreviousHeadStateCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ViewPreviousHeadState", reflect.TypeOf((*MockSyncedData)(nil).ViewPreviousHeadState), fn)
	return &MockSyncedDataViewPreviousHeadStateCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockSyncedDataViewPreviousHeadStateCall) Do(f func(synced_data.ViewHeadStateFn) error) *MockSyncedDataViewPreviousHeadStateCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockSyncedDataViewPreviousHeadStateCall) DoAndReturn(f func(synced_data.ViewHeadStateFn) error) *MockSyncedDataViewPreviousHeadStateCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
