// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/commonspace/object/acl/syncacl (interfaces: SyncClient,SyncAcl)
//
// Generated by this command:
//
//	mockgen -destination mock_syncacl/mock_syncacl.go github.com/anyproto/any-sync/commonspace/object/acl/syncacl SyncClient,SyncAcl
//

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

import (
	context "context"
	reflect "reflect"

	app "github.com/anyproto/any-sync/app"
	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
	headupdater "github.com/anyproto/any-sync/commonspace/object/acl/syncacl/headupdater"
	response "github.com/anyproto/any-sync/commonspace/object/acl/syncacl/response"
	objectmessages "github.com/anyproto/any-sync/commonspace/sync/objectsync/objectmessages"
	syncdeps "github.com/anyproto/any-sync/commonspace/sync/syncdeps"
	syncstatus "github.com/anyproto/any-sync/commonspace/syncstatus"
	consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
	peer "github.com/anyproto/any-sync/net/peer"
	crypto "github.com/anyproto/any-sync/util/crypto"
	gomock "go.uber.org/mock/gomock"
	proto "google.golang.org/protobuf/proto"
	drpc "storj.io/drpc"
)

// MockSyncClient is a mock of SyncClient interface.
type MockSyncClient struct {
	ctrl     *gomock.Controller
	recorder *MockSyncClientMockRecorder
	isgomock struct{}
}

// MockSyncClientMockRecorder is the mock recorder for MockSyncClient.
type MockSyncClientMockRecorder struct {
	mock *MockSyncClient
}

// NewMockSyncClient creates a new mock instance.
func NewMockSyncClient(ctrl *gomock.Controller) *MockSyncClient {
	mock := &MockSyncClient{ctrl: ctrl}
	mock.recorder = &MockSyncClientMockRecorder{mock}
	return mock
}

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

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

// Broadcast indicates an expected call of Broadcast.
func (mr *MockSyncClientMockRecorder) Broadcast(ctx, headUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Broadcast", reflect.TypeOf((*MockSyncClient)(nil).Broadcast), ctx, headUpdate)
}

// CreateFullSyncRequest mocks base method.
func (m *MockSyncClient) CreateFullSyncRequest(peerId string, l list.AclList) *objectmessages.Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullSyncRequest", peerId, l)
	ret0, _ := ret[0].(*objectmessages.Request)
	return ret0
}

// CreateFullSyncRequest indicates an expected call of CreateFullSyncRequest.
func (mr *MockSyncClientMockRecorder) CreateFullSyncRequest(peerId, l any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncRequest", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncRequest), peerId, l)
}

// CreateFullSyncResponse mocks base method.
func (m *MockSyncClient) CreateFullSyncResponse(l list.AclList, theirHead string) (*response.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFullSyncResponse", l, theirHead)
	ret0, _ := ret[0].(*response.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFullSyncResponse indicates an expected call of CreateFullSyncResponse.
func (mr *MockSyncClientMockRecorder) CreateFullSyncResponse(l, theirHead any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFullSyncResponse", reflect.TypeOf((*MockSyncClient)(nil).CreateFullSyncResponse), l, theirHead)
}

// CreateHeadUpdate mocks base method.
func (m *MockSyncClient) CreateHeadUpdate(l list.AclList, added []*consensusproto.RawRecordWithId) (*objectmessages.HeadUpdate, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateHeadUpdate", l, added)
	ret0, _ := ret[0].(*objectmessages.HeadUpdate)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateHeadUpdate indicates an expected call of CreateHeadUpdate.
func (mr *MockSyncClientMockRecorder) CreateHeadUpdate(l, added any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateHeadUpdate", reflect.TypeOf((*MockSyncClient)(nil).CreateHeadUpdate), l, added)
}

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

// QueueRequest indicates an expected call of QueueRequest.
func (mr *MockSyncClientMockRecorder) QueueRequest(ctx, req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueueRequest", reflect.TypeOf((*MockSyncClient)(nil).QueueRequest), ctx, req)
}

// MockSyncAcl is a mock of SyncAcl interface.
type MockSyncAcl struct {
	ctrl     *gomock.Controller
	recorder *MockSyncAclMockRecorder
	isgomock struct{}
}

// MockSyncAclMockRecorder is the mock recorder for MockSyncAcl.
type MockSyncAclMockRecorder struct {
	mock *MockSyncAcl
}

// NewMockSyncAcl creates a new mock instance.
func NewMockSyncAcl(ctrl *gomock.Controller) *MockSyncAcl {
	mock := &MockSyncAcl{ctrl: ctrl}
	mock.recorder = &MockSyncAclMockRecorder{mock}
	return mock
}

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

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

// AclState indicates an expected call of AclState.
func (mr *MockSyncAclMockRecorder) AclState() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AclState", reflect.TypeOf((*MockSyncAcl)(nil).AclState))
}

// AddRawRecord mocks base method.
func (m *MockSyncAcl) AddRawRecord(rawRec *consensusproto.RawRecordWithId) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRawRecord", rawRec)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddRawRecord indicates an expected call of AddRawRecord.
func (mr *MockSyncAclMockRecorder) AddRawRecord(rawRec any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecord), rawRec)
}

// AddRawRecords mocks base method.
func (m *MockSyncAcl) AddRawRecords(rawRecords []*consensusproto.RawRecordWithId) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddRawRecords", rawRecords)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddRawRecords indicates an expected call of AddRawRecords.
func (mr *MockSyncAclMockRecorder) AddRawRecords(rawRecords any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRawRecords", reflect.TypeOf((*MockSyncAcl)(nil).AddRawRecords), rawRecords)
}

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

// Close indicates an expected call of Close.
func (mr *MockSyncAclMockRecorder) Close(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSyncAcl)(nil).Close), ctx)
}

// Get mocks base method.
func (m *MockSyncAcl) Get(id string) (*list.AclRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", id)
	ret0, _ := ret[0].(*list.AclRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockSyncAclMockRecorder) Get(id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSyncAcl)(nil).Get), id)
}

// GetIndex mocks base method.
func (m *MockSyncAcl) GetIndex(idx int) (*list.AclRecord, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIndex", idx)
	ret0, _ := ret[0].(*list.AclRecord)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetIndex indicates an expected call of GetIndex.
func (mr *MockSyncAclMockRecorder) GetIndex(idx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIndex", reflect.TypeOf((*MockSyncAcl)(nil).GetIndex), idx)
}

// HandleHeadUpdate mocks base method.
func (m *MockSyncAcl) HandleHeadUpdate(ctx context.Context, statusUpdater syncstatus.StatusUpdater, headUpdate drpc.Message) (syncdeps.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleHeadUpdate", ctx, statusUpdater, headUpdate)
	ret0, _ := ret[0].(syncdeps.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleHeadUpdate indicates an expected call of HandleHeadUpdate.
func (mr *MockSyncAclMockRecorder) HandleHeadUpdate(ctx, statusUpdater, headUpdate any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleHeadUpdate", reflect.TypeOf((*MockSyncAcl)(nil).HandleHeadUpdate), ctx, statusUpdater, headUpdate)
}

// HandleResponse mocks base method.
func (m *MockSyncAcl) HandleResponse(ctx context.Context, peerId, objectId string, resp syncdeps.Response) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleResponse", ctx, peerId, objectId, resp)
	ret0, _ := ret[0].(error)
	return ret0
}

// HandleResponse indicates an expected call of HandleResponse.
func (mr *MockSyncAclMockRecorder) HandleResponse(ctx, peerId, objectId, resp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResponse", reflect.TypeOf((*MockSyncAcl)(nil).HandleResponse), ctx, peerId, objectId, resp)
}

// HandleStreamRequest mocks base method.
func (m *MockSyncAcl) HandleStreamRequest(ctx context.Context, rq syncdeps.Request, updater syncdeps.QueueSizeUpdater, send func(proto.Message) error) (syncdeps.Request, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleStreamRequest", ctx, rq, updater, send)
	ret0, _ := ret[0].(syncdeps.Request)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleStreamRequest indicates an expected call of HandleStreamRequest.
func (mr *MockSyncAclMockRecorder) HandleStreamRequest(ctx, rq, updater, send any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleStreamRequest", reflect.TypeOf((*MockSyncAcl)(nil).HandleStreamRequest), ctx, rq, updater, send)
}

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

// HasHead indicates an expected call of HasHead.
func (mr *MockSyncAclMockRecorder) HasHead(head any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasHead", reflect.TypeOf((*MockSyncAcl)(nil).HasHead), head)
}

// Head mocks base method.
func (m *MockSyncAcl) Head() *list.AclRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Head")
	ret0, _ := ret[0].(*list.AclRecord)
	return ret0
}

// Head indicates an expected call of Head.
func (mr *MockSyncAclMockRecorder) Head() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockSyncAcl)(nil).Head))
}

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

// Id indicates an expected call of Id.
func (mr *MockSyncAclMockRecorder) Id() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Id", reflect.TypeOf((*MockSyncAcl)(nil).Id))
}

// Init mocks base method.
func (m *MockSyncAcl) Init(a *app.App) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Init", a)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init.
func (mr *MockSyncAclMockRecorder) Init(a any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockSyncAcl)(nil).Init), a)
}

// IsAfter mocks base method.
func (m *MockSyncAcl) IsAfter(first, second string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsAfter", first, second)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsAfter indicates an expected call of IsAfter.
func (mr *MockSyncAclMockRecorder) IsAfter(first, second any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockSyncAcl)(nil).IsAfter), first, second)
}

// Iterate mocks base method.
func (m *MockSyncAcl) Iterate(iterFunc list.IterFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Iterate", iterFunc)
}

// Iterate indicates an expected call of Iterate.
func (mr *MockSyncAclMockRecorder) Iterate(iterFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Iterate", reflect.TypeOf((*MockSyncAcl)(nil).Iterate), iterFunc)
}

// IterateFrom mocks base method.
func (m *MockSyncAcl) IterateFrom(startId string, iterFunc list.IterFunc) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IterateFrom", startId, iterFunc)
}

// IterateFrom indicates an expected call of IterateFrom.
func (mr *MockSyncAclMockRecorder) IterateFrom(startId, iterFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockSyncAcl)(nil).IterateFrom), startId, iterFunc)
}

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

// KeyStorage indicates an expected call of KeyStorage.
func (mr *MockSyncAclMockRecorder) KeyStorage() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeyStorage", reflect.TypeOf((*MockSyncAcl)(nil).KeyStorage))
}

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

// Lock indicates an expected call of Lock.
func (mr *MockSyncAclMockRecorder) Lock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Lock", reflect.TypeOf((*MockSyncAcl)(nil).Lock))
}

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

// Name indicates an expected call of Name.
func (mr *MockSyncAclMockRecorder) Name() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Name", reflect.TypeOf((*MockSyncAcl)(nil).Name))
}

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

// RLock indicates an expected call of RLock.
func (mr *MockSyncAclMockRecorder) RLock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RLock", reflect.TypeOf((*MockSyncAcl)(nil).RLock))
}

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

// RUnlock indicates an expected call of RUnlock.
func (mr *MockSyncAclMockRecorder) RUnlock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RUnlock", reflect.TypeOf((*MockSyncAcl)(nil).RUnlock))
}

// RecordBuilder mocks base method.
func (m *MockSyncAcl) RecordBuilder() list.AclRecordBuilder {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecordBuilder")
	ret0, _ := ret[0].(list.AclRecordBuilder)
	return ret0
}

// RecordBuilder indicates an expected call of RecordBuilder.
func (mr *MockSyncAclMockRecorder) RecordBuilder() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordBuilder", reflect.TypeOf((*MockSyncAcl)(nil).RecordBuilder))
}

// Records mocks base method.
func (m *MockSyncAcl) Records() []*list.AclRecord {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Records")
	ret0, _ := ret[0].([]*list.AclRecord)
	return ret0
}

// Records indicates an expected call of Records.
func (mr *MockSyncAclMockRecorder) Records() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Records", reflect.TypeOf((*MockSyncAcl)(nil).Records))
}

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

// RecordsAfter indicates an expected call of RecordsAfter.
func (mr *MockSyncAclMockRecorder) RecordsAfter(ctx, id any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsAfter", reflect.TypeOf((*MockSyncAcl)(nil).RecordsAfter), ctx, id)
}

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

// RecordsBefore indicates an expected call of RecordsBefore.
func (mr *MockSyncAclMockRecorder) RecordsBefore(ctx, headId any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecordsBefore", reflect.TypeOf((*MockSyncAcl)(nil).RecordsBefore), ctx, headId)
}

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

// ResponseCollector indicates an expected call of ResponseCollector.
func (mr *MockSyncAclMockRecorder) ResponseCollector() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponseCollector", reflect.TypeOf((*MockSyncAcl)(nil).ResponseCollector))
}

// Root mocks base method.
func (m *MockSyncAcl) Root() *consensusproto.RawRecordWithId {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Root")
	ret0, _ := ret[0].(*consensusproto.RawRecordWithId)
	return ret0
}

// Root indicates an expected call of Root.
func (mr *MockSyncAclMockRecorder) Root() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Root", reflect.TypeOf((*MockSyncAcl)(nil).Root))
}

// Run mocks base method.
func (m *MockSyncAcl) 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 *MockSyncAclMockRecorder) Run(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockSyncAcl)(nil).Run), ctx)
}

// SetAclUpdater mocks base method.
func (m *MockSyncAcl) SetAclUpdater(updater headupdater.AclUpdater) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetAclUpdater", updater)
}

// SetAclUpdater indicates an expected call of SetAclUpdater.
func (mr *MockSyncAclMockRecorder) SetAclUpdater(updater any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAclUpdater", reflect.TypeOf((*MockSyncAcl)(nil).SetAclUpdater), updater)
}

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

// SyncWithPeer indicates an expected call of SyncWithPeer.
func (mr *MockSyncAclMockRecorder) SyncWithPeer(ctx, p any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SyncWithPeer", reflect.TypeOf((*MockSyncAcl)(nil).SyncWithPeer), ctx, p)
}

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

// Unlock indicates an expected call of Unlock.
func (mr *MockSyncAclMockRecorder) Unlock() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Unlock", reflect.TypeOf((*MockSyncAcl)(nil).Unlock))
}

// ValidateRawRecord mocks base method.
func (m *MockSyncAcl) ValidateRawRecord(rawRec *consensusproto.RawRecord, afterValid func(*list.AclState) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateRawRecord", rawRec, afterValid)
	ret0, _ := ret[0].(error)
	return ret0
}

// ValidateRawRecord indicates an expected call of ValidateRawRecord.
func (mr *MockSyncAclMockRecorder) ValidateRawRecord(rawRec, afterValid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockSyncAcl)(nil).ValidateRawRecord), rawRec, afterValid)
}
