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

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

import (
	context "context"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
	isgomock struct{}
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

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

// Close indicates an expected call of Close.
func (mr *MockClientMockRecorder) Close() *MockClientCloseCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockClient)(nil).Close))
	return &MockClientCloseCall{Call: call}
}

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

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

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

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

// FetchCheckpoint mocks base method.
func (m *MockClient) FetchCheckpoint(ctx context.Context, number int64) (*Checkpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchCheckpoint", ctx, number)
	ret0, _ := ret[0].(*Checkpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchCheckpoint indicates an expected call of FetchCheckpoint.
func (mr *MockClientMockRecorder) FetchCheckpoint(ctx, number any) *MockClientFetchCheckpointCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCheckpoint", reflect.TypeOf((*MockClient)(nil).FetchCheckpoint), ctx, number)
	return &MockClientFetchCheckpointCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockClientFetchCheckpointCall) Do(f func(context.Context, int64) (*Checkpoint, error)) *MockClientFetchCheckpointCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClientFetchCheckpointCall) DoAndReturn(f func(context.Context, int64) (*Checkpoint, error)) *MockClientFetchCheckpointCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// FetchCheckpointCount indicates an expected call of FetchCheckpointCount.
func (mr *MockClientMockRecorder) FetchCheckpointCount(ctx any) *MockClientFetchCheckpointCountCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCheckpointCount", reflect.TypeOf((*MockClient)(nil).FetchCheckpointCount), ctx)
	return &MockClientFetchCheckpointCountCall{Call: call}
}

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

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

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

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

// FetchCheckpoints mocks base method.
func (m *MockClient) FetchCheckpoints(ctx context.Context, page, limit uint64) ([]*Checkpoint, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchCheckpoints", ctx, page, limit)
	ret0, _ := ret[0].([]*Checkpoint)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchCheckpoints indicates an expected call of FetchCheckpoints.
func (mr *MockClientMockRecorder) FetchCheckpoints(ctx, page, limit any) *MockClientFetchCheckpointsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchCheckpoints", reflect.TypeOf((*MockClient)(nil).FetchCheckpoints), ctx, page, limit)
	return &MockClientFetchCheckpointsCall{Call: call}
}

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

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

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

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

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

// FetchFirstMilestoneNum indicates an expected call of FetchFirstMilestoneNum.
func (mr *MockClientMockRecorder) FetchFirstMilestoneNum(ctx any) *MockClientFetchFirstMilestoneNumCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchFirstMilestoneNum", reflect.TypeOf((*MockClient)(nil).FetchFirstMilestoneNum), ctx)
	return &MockClientFetchFirstMilestoneNumCall{Call: call}
}

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

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

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

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

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

// FetchLastNoAckMilestone indicates an expected call of FetchLastNoAckMilestone.
func (mr *MockClientMockRecorder) FetchLastNoAckMilestone(ctx any) *MockClientFetchLastNoAckMilestoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchLastNoAckMilestone", reflect.TypeOf((*MockClient)(nil).FetchLastNoAckMilestone), ctx)
	return &MockClientFetchLastNoAckMilestoneCall{Call: call}
}

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

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

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

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

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

// FetchLatestSpan indicates an expected call of FetchLatestSpan.
func (mr *MockClientMockRecorder) FetchLatestSpan(ctx any) *MockClientFetchLatestSpanCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchLatestSpan", reflect.TypeOf((*MockClient)(nil).FetchLatestSpan), ctx)
	return &MockClientFetchLatestSpanCall{Call: call}
}

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

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

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

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

// FetchMilestone mocks base method.
func (m *MockClient) FetchMilestone(ctx context.Context, number int64) (*Milestone, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchMilestone", ctx, number)
	ret0, _ := ret[0].(*Milestone)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchMilestone indicates an expected call of FetchMilestone.
func (mr *MockClientMockRecorder) FetchMilestone(ctx, number any) *MockClientFetchMilestoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMilestone", reflect.TypeOf((*MockClient)(nil).FetchMilestone), ctx, number)
	return &MockClientFetchMilestoneCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockClientFetchMilestoneCall) Do(f func(context.Context, int64) (*Milestone, error)) *MockClientFetchMilestoneCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClientFetchMilestoneCall) DoAndReturn(f func(context.Context, int64) (*Milestone, error)) *MockClientFetchMilestoneCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// FetchMilestoneCount indicates an expected call of FetchMilestoneCount.
func (mr *MockClientMockRecorder) FetchMilestoneCount(ctx any) *MockClientFetchMilestoneCountCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMilestoneCount", reflect.TypeOf((*MockClient)(nil).FetchMilestoneCount), ctx)
	return &MockClientFetchMilestoneCountCall{Call: call}
}

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

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

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

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

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

// FetchMilestoneID indicates an expected call of FetchMilestoneID.
func (mr *MockClientMockRecorder) FetchMilestoneID(ctx, milestoneID any) *MockClientFetchMilestoneIDCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMilestoneID", reflect.TypeOf((*MockClient)(nil).FetchMilestoneID), ctx, milestoneID)
	return &MockClientFetchMilestoneIDCall{Call: call}
}

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

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

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

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

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

// FetchNoAckMilestone indicates an expected call of FetchNoAckMilestone.
func (mr *MockClientMockRecorder) FetchNoAckMilestone(ctx, milestoneID any) *MockClientFetchNoAckMilestoneCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchNoAckMilestone", reflect.TypeOf((*MockClient)(nil).FetchNoAckMilestone), ctx, milestoneID)
	return &MockClientFetchNoAckMilestoneCall{Call: call}
}

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

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

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

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

// FetchSpan mocks base method.
func (m *MockClient) FetchSpan(ctx context.Context, spanID uint64) (*Span, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchSpan", ctx, spanID)
	ret0, _ := ret[0].(*Span)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchSpan indicates an expected call of FetchSpan.
func (mr *MockClientMockRecorder) FetchSpan(ctx, spanID any) *MockClientFetchSpanCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchSpan", reflect.TypeOf((*MockClient)(nil).FetchSpan), ctx, spanID)
	return &MockClientFetchSpanCall{Call: call}
}

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

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

// Do rewrite *gomock.Call.Do
func (c *MockClientFetchSpanCall) Do(f func(context.Context, uint64) (*Span, error)) *MockClientFetchSpanCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClientFetchSpanCall) DoAndReturn(f func(context.Context, uint64) (*Span, error)) *MockClientFetchSpanCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// FetchSpans mocks base method.
func (m *MockClient) FetchSpans(ctx context.Context, page, limit uint64) ([]*Span, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchSpans", ctx, page, limit)
	ret0, _ := ret[0].([]*Span)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchSpans indicates an expected call of FetchSpans.
func (mr *MockClientMockRecorder) FetchSpans(ctx, page, limit any) *MockClientFetchSpansCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchSpans", reflect.TypeOf((*MockClient)(nil).FetchSpans), ctx, page, limit)
	return &MockClientFetchSpansCall{Call: call}
}

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

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

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

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

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

// FetchStatus indicates an expected call of FetchStatus.
func (mr *MockClientMockRecorder) FetchStatus(ctx any) *MockClientFetchStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchStatus", reflect.TypeOf((*MockClient)(nil).FetchStatus), ctx)
	return &MockClientFetchStatusCall{Call: call}
}

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

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

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

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