// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/erigontech/erigon/polygon/sync (interfaces: Store)
//
// Generated by this command:
//
//	mockgen -typed=true -destination=./store_mock.go -package=sync . Store
//

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

import (
	context "context"
	reflect "reflect"

	types "github.com/erigontech/erigon/execution/types"
	gomock "go.uber.org/mock/gomock"
)

// MockStore is a mock of Store interface.
type MockStore struct {
	ctrl     *gomock.Controller
	recorder *MockStoreMockRecorder
	isgomock struct{}
}

// MockStoreMockRecorder is the mock recorder for MockStore.
type MockStoreMockRecorder struct {
	mock *MockStore
}

// NewMockStore creates a new mock instance.
func NewMockStore(ctrl *gomock.Controller) *MockStore {
	mock := &MockStore{ctrl: ctrl}
	mock.recorder = &MockStoreMockRecorder{mock}
	return mock
}

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

// Flush mocks base method.
func (m *MockStore) Flush(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Flush", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Flush indicates an expected call of Flush.
func (mr *MockStoreMockRecorder) Flush(ctx any) *MockStoreFlushCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Flush", reflect.TypeOf((*MockStore)(nil).Flush), ctx)
	return &MockStoreFlushCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockStoreFlushCall) Do(f func(context.Context) error) *MockStoreFlushCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreFlushCall) DoAndReturn(f func(context.Context) error) *MockStoreFlushCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// InsertBlocks mocks base method.
func (m *MockStore) InsertBlocks(ctx context.Context, blocks []*types.Block) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InsertBlocks", ctx, blocks)
	ret0, _ := ret[0].(error)
	return ret0
}

// InsertBlocks indicates an expected call of InsertBlocks.
func (mr *MockStoreMockRecorder) InsertBlocks(ctx, blocks any) *MockStoreInsertBlocksCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertBlocks", reflect.TypeOf((*MockStore)(nil).InsertBlocks), ctx, blocks)
	return &MockStoreInsertBlocksCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockStoreInsertBlocksCall) Do(f func(context.Context, []*types.Block) error) *MockStoreInsertBlocksCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreInsertBlocksCall) DoAndReturn(f func(context.Context, []*types.Block) error) *MockStoreInsertBlocksCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Prepare mocks base method.
func (m *MockStore) Prepare(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Prepare", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Prepare indicates an expected call of Prepare.
func (mr *MockStoreMockRecorder) Prepare(ctx any) *MockStorePrepareCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockStore)(nil).Prepare), ctx)
	return &MockStorePrepareCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockStorePrepareCall) Do(f func(context.Context) error) *MockStorePrepareCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStorePrepareCall) DoAndReturn(f func(context.Context) error) *MockStorePrepareCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Run mocks base method.
func (m *MockStore) Run(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Run", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

// Run indicates an expected call of Run.
func (mr *MockStoreMockRecorder) Run(ctx any) *MockStoreRunCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockStore)(nil).Run), ctx)
	return &MockStoreRunCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockStoreRunCall) Do(f func(context.Context) error) *MockStoreRunCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockStoreRunCall) DoAndReturn(f func(context.Context) error) *MockStoreRunCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
