// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/anyproto/any-sync/app/ldiff (interfaces: Diff,Remote,DiffContainer)
//
// Generated by this command:
//
//	mockgen -destination mock_ldiff/mock_ldiff.go github.com/anyproto/any-sync/app/ldiff Diff,Remote,DiffContainer
//

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

import (
	context "context"
	reflect "reflect"

	ldiff "github.com/anyproto/any-sync/app/ldiff"
	spacesyncproto "github.com/anyproto/any-sync/commonspace/spacesyncproto"
	gomock "go.uber.org/mock/gomock"
)

// MockDiff is a mock of Diff interface.
type MockDiff struct {
	ctrl     *gomock.Controller
	recorder *MockDiffMockRecorder
	isgomock struct{}
}

// MockDiffMockRecorder is the mock recorder for MockDiff.
type MockDiffMockRecorder struct {
	mock *MockDiff
}

// NewMockDiff creates a new mock instance.
func NewMockDiff(ctrl *gomock.Controller) *MockDiff {
	mock := &MockDiff{ctrl: ctrl}
	mock.recorder = &MockDiffMockRecorder{mock}
	return mock
}

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

// Diff mocks base method.
func (m *MockDiff) Diff(ctx context.Context, dl ldiff.Remote) ([]string, []string, []string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Diff", ctx, dl)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].([]string)
	ret2, _ := ret[2].([]string)
	ret3, _ := ret[3].(error)
	return ret0, ret1, ret2, ret3
}

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

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

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

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

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

// Elements mocks base method.
func (m *MockDiff) Elements() []ldiff.Element {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Elements")
	ret0, _ := ret[0].([]ldiff.Element)
	return ret0
}

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

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

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

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

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

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

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

// Ranges mocks base method.
func (m *MockDiff) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff.RangeResult) ([]ldiff.RangeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ranges", ctx, ranges, resBuf)
	ret0, _ := ret[0].([]ldiff.RangeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ranges indicates an expected call of Ranges.
func (mr *MockDiffMockRecorder) Ranges(ctx, ranges, resBuf any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockDiff)(nil).Ranges), ctx, ranges, resBuf)
}

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

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

// Set mocks base method.
func (m *MockDiff) Set(elements ...ldiff.Element) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range elements {
		varargs = append(varargs, a)
	}
	m.ctrl.Call(m, "Set", varargs...)
}

// Set indicates an expected call of Set.
func (mr *MockDiffMockRecorder) Set(elements ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockDiff)(nil).Set), elements...)
}

// MockRemote is a mock of Remote interface.
type MockRemote struct {
	ctrl     *gomock.Controller
	recorder *MockRemoteMockRecorder
	isgomock struct{}
}

// MockRemoteMockRecorder is the mock recorder for MockRemote.
type MockRemoteMockRecorder struct {
	mock *MockRemote
}

// NewMockRemote creates a new mock instance.
func NewMockRemote(ctrl *gomock.Controller) *MockRemote {
	mock := &MockRemote{ctrl: ctrl}
	mock.recorder = &MockRemoteMockRecorder{mock}
	return mock
}

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

// Ranges mocks base method.
func (m *MockRemote) Ranges(ctx context.Context, ranges []ldiff.Range, resBuf []ldiff.RangeResult) ([]ldiff.RangeResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ranges", ctx, ranges, resBuf)
	ret0, _ := ret[0].([]ldiff.RangeResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Ranges indicates an expected call of Ranges.
func (mr *MockRemoteMockRecorder) Ranges(ctx, ranges, resBuf any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ranges", reflect.TypeOf((*MockRemote)(nil).Ranges), ctx, ranges, resBuf)
}

// MockDiffContainer is a mock of DiffContainer interface.
type MockDiffContainer struct {
	ctrl     *gomock.Controller
	recorder *MockDiffContainerMockRecorder
	isgomock struct{}
}

// MockDiffContainerMockRecorder is the mock recorder for MockDiffContainer.
type MockDiffContainerMockRecorder struct {
	mock *MockDiffContainer
}

// NewMockDiffContainer creates a new mock instance.
func NewMockDiffContainer(ctrl *gomock.Controller) *MockDiffContainer {
	mock := &MockDiffContainer{ctrl: ctrl}
	mock.recorder = &MockDiffContainerMockRecorder{mock}
	return mock
}

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

// DiffTypeCheck mocks base method.
func (m *MockDiffContainer) DiffTypeCheck(ctx context.Context, typeChecker ldiff.RemoteTypeChecker) (bool, ldiff.Diff, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DiffTypeCheck", ctx, typeChecker)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(ldiff.Diff)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// NewDiff mocks base method.
func (m *MockDiffContainer) NewDiff() ldiff.Diff {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDiff")
	ret0, _ := ret[0].(ldiff.Diff)
	return ret0
}

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

// OldDiff mocks base method.
func (m *MockDiffContainer) OldDiff() ldiff.Diff {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OldDiff")
	ret0, _ := ret[0].(ldiff.Diff)
	return ret0
}

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

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

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