// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/commonspace/object/acl/list (interfaces: AclList,Storage)
//
// Generated by this command:
//
//	mockgen -destination mock_list/mock_list.go github.com/anyproto/any-sync/commonspace/object/acl/list AclList,Storage
//

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

import (
	context "context"
	reflect "reflect"

	list "github.com/anyproto/any-sync/commonspace/object/acl/list"
	consensusproto "github.com/anyproto/any-sync/consensus/consensusproto"
	crypto "github.com/anyproto/any-sync/util/crypto"
	gomock "go.uber.org/mock/gomock"
)

// MockAclList is a mock of AclList interface.
type MockAclList struct {
	ctrl     *gomock.Controller
	recorder *MockAclListMockRecorder
	isgomock struct{}
}

// MockAclListMockRecorder is the mock recorder for MockAclList.
type MockAclListMockRecorder struct {
	mock *MockAclList
}

// NewMockAclList creates a new mock instance.
func NewMockAclList(ctrl *gomock.Controller) *MockAclList {
	mock := &MockAclList{ctrl: ctrl}
	mock.recorder = &MockAclListMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// IsAfter mocks base method.
func (m *MockAclList) 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 *MockAclListMockRecorder) IsAfter(first, second any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAfter", reflect.TypeOf((*MockAclList)(nil).IsAfter), first, second)
}

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

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

// IterateFrom mocks base method.
func (m *MockAclList) 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 *MockAclListMockRecorder) IterateFrom(startId, iterFunc any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IterateFrom", reflect.TypeOf((*MockAclList)(nil).IterateFrom), startId, iterFunc)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ValidateRawRecord mocks base method.
func (m *MockAclList) 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 *MockAclListMockRecorder) ValidateRawRecord(rawRec, afterValid any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateRawRecord", reflect.TypeOf((*MockAclList)(nil).ValidateRawRecord), rawRec, afterValid)
}

// MockStorage is a mock of Storage interface.
type MockStorage struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMockRecorder
	isgomock struct{}
}

// MockStorageMockRecorder is the mock recorder for MockStorage.
type MockStorageMockRecorder struct {
	mock *MockStorage
}

// NewMockStorage creates a new mock instance.
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
	mock := &MockStorage{ctrl: ctrl}
	mock.recorder = &MockStorageMockRecorder{mock}
	return mock
}

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

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

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

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

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

// GetAfterOrder mocks base method.
func (m *MockStorage) GetAfterOrder(ctx context.Context, order int, iter list.StorageIterator) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAfterOrder", ctx, order, iter)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetAfterOrder indicates an expected call of GetAfterOrder.
func (mr *MockStorageMockRecorder) GetAfterOrder(ctx, order, iter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAfterOrder", reflect.TypeOf((*MockStorage)(nil).GetAfterOrder), ctx, order, iter)
}

// GetBeforeOrder mocks base method.
func (m *MockStorage) GetBeforeOrder(ctx context.Context, order int, iter list.StorageIterator) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBeforeOrder", ctx, order, iter)
	ret0, _ := ret[0].(error)
	return ret0
}

// GetBeforeOrder indicates an expected call of GetBeforeOrder.
func (mr *MockStorageMockRecorder) GetBeforeOrder(ctx, order, iter any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBeforeOrder", reflect.TypeOf((*MockStorage)(nil).GetBeforeOrder), ctx, order, iter)
}

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

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

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

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

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

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

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