//                           _       _
// __      _____  __ ___   ___  __ _| |_ ___
// \ \ /\ / / _ \/ _` \ \ / / |/ _` | __/ _ \
//  \ V  V /  __/ (_| |\ V /| | (_| | ||  __/
//   \_/\_/ \___|\__,_| \_/ |_|\__,_|\__\___|
//
//  Copyright © 2016 - 2026 Weaviate B.V. All rights reserved.
//
//  CONTACT: hello@weaviate.io
//

// Code generated by mockery v2.53.5. DO NOT EDIT.

package types

import (
	context "context"

	mock "github.com/stretchr/testify/mock"
	hashtree "github.com/weaviate/weaviate/usecases/replica/hashtree"

	objects "github.com/weaviate/weaviate/usecases/objects"

	replica "github.com/weaviate/weaviate/usecases/replica"

	routertypes "github.com/weaviate/weaviate/cluster/router/types"

	storobj "github.com/weaviate/weaviate/entities/storobj"

	strfmt "github.com/go-openapi/strfmt"

	time "time"
)

// MockReplicator is an autogenerated mock type for the Replicator type
type MockReplicator struct {
	mock.Mock
}

type MockReplicator_Expecter struct {
	mock *mock.Mock
}

func (_m *MockReplicator) EXPECT() *MockReplicator_Expecter {
	return &MockReplicator_Expecter{mock: &_m.Mock}
}

// AbortReplication provides a mock function with given fields: className, shardName, requestID
func (_m *MockReplicator) AbortReplication(className string, shardName string, requestID string) interface{} {
	ret := _m.Called(className, shardName, requestID)

	if len(ret) == 0 {
		panic("no return value specified for AbortReplication")
	}

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(string, string, string) interface{}); ok {
		r0 = rf(className, shardName, requestID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	return r0
}

// MockReplicator_AbortReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortReplication'
type MockReplicator_AbortReplication_Call struct {
	*mock.Call
}

// AbortReplication is a helper method to define mock.On call
//   - className string
//   - shardName string
//   - requestID string
func (_e *MockReplicator_Expecter) AbortReplication(className interface{}, shardName interface{}, requestID interface{}) *MockReplicator_AbortReplication_Call {
	return &MockReplicator_AbortReplication_Call{Call: _e.mock.On("AbortReplication", className, shardName, requestID)}
}

func (_c *MockReplicator_AbortReplication_Call) Run(run func(className string, shardName string, requestID string)) *MockReplicator_AbortReplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockReplicator_AbortReplication_Call) Return(_a0 interface{}) *MockReplicator_AbortReplication_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_AbortReplication_Call) RunAndReturn(run func(string, string, string) interface{}) *MockReplicator_AbortReplication_Call {
	_c.Call.Return(run)
	return _c
}

// CommitReplication provides a mock function with given fields: className, shardName, requestID
func (_m *MockReplicator) CommitReplication(className string, shardName string, requestID string) interface{} {
	ret := _m.Called(className, shardName, requestID)

	if len(ret) == 0 {
		panic("no return value specified for CommitReplication")
	}

	var r0 interface{}
	if rf, ok := ret.Get(0).(func(string, string, string) interface{}); ok {
		r0 = rf(className, shardName, requestID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(interface{})
		}
	}

	return r0
}

// MockReplicator_CommitReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommitReplication'
type MockReplicator_CommitReplication_Call struct {
	*mock.Call
}

// CommitReplication is a helper method to define mock.On call
//   - className string
//   - shardName string
//   - requestID string
func (_e *MockReplicator_Expecter) CommitReplication(className interface{}, shardName interface{}, requestID interface{}) *MockReplicator_CommitReplication_Call {
	return &MockReplicator_CommitReplication_Call{Call: _e.mock.On("CommitReplication", className, shardName, requestID)}
}

func (_c *MockReplicator_CommitReplication_Call) Run(run func(className string, shardName string, requestID string)) *MockReplicator_CommitReplication_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockReplicator_CommitReplication_Call) Return(_a0 interface{}) *MockReplicator_CommitReplication_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_CommitReplication_Call) RunAndReturn(run func(string, string, string) interface{}) *MockReplicator_CommitReplication_Call {
	_c.Call.Return(run)
	return _c
}

// DigestObjects provides a mock function with given fields: ctx, className, shardName, ids
func (_m *MockReplicator) DigestObjects(ctx context.Context, className string, shardName string, ids []strfmt.UUID) ([]routertypes.RepairResponse, error) {
	ret := _m.Called(ctx, className, shardName, ids)

	if len(ret) == 0 {
		panic("no return value specified for DigestObjects")
	}

	var r0 []routertypes.RepairResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []strfmt.UUID) ([]routertypes.RepairResponse, error)); ok {
		return rf(ctx, className, shardName, ids)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []strfmt.UUID) []routertypes.RepairResponse); ok {
		r0 = rf(ctx, className, shardName, ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]routertypes.RepairResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, []strfmt.UUID) error); ok {
		r1 = rf(ctx, className, shardName, ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockReplicator_DigestObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DigestObjects'
type MockReplicator_DigestObjects_Call struct {
	*mock.Call
}

// DigestObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - ids []strfmt.UUID
func (_e *MockReplicator_Expecter) DigestObjects(ctx interface{}, className interface{}, shardName interface{}, ids interface{}) *MockReplicator_DigestObjects_Call {
	return &MockReplicator_DigestObjects_Call{Call: _e.mock.On("DigestObjects", ctx, className, shardName, ids)}
}

func (_c *MockReplicator_DigestObjects_Call) Run(run func(ctx context.Context, className string, shardName string, ids []strfmt.UUID)) *MockReplicator_DigestObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]strfmt.UUID))
	})
	return _c
}

func (_c *MockReplicator_DigestObjects_Call) Return(result []routertypes.RepairResponse, err error) *MockReplicator_DigestObjects_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockReplicator_DigestObjects_Call) RunAndReturn(run func(context.Context, string, string, []strfmt.UUID) ([]routertypes.RepairResponse, error)) *MockReplicator_DigestObjects_Call {
	_c.Call.Return(run)
	return _c
}

// DigestObjectsInRange provides a mock function with given fields: ctx, className, shardName, initialUUID, finalUUID, limit
func (_m *MockReplicator) DigestObjectsInRange(ctx context.Context, className string, shardName string, initialUUID strfmt.UUID, finalUUID strfmt.UUID, limit int) ([]routertypes.RepairResponse, error) {
	ret := _m.Called(ctx, className, shardName, initialUUID, finalUUID, limit)

	if len(ret) == 0 {
		panic("no return value specified for DigestObjectsInRange")
	}

	var r0 []routertypes.RepairResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, strfmt.UUID, strfmt.UUID, int) ([]routertypes.RepairResponse, error)); ok {
		return rf(ctx, className, shardName, initialUUID, finalUUID, limit)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, strfmt.UUID, strfmt.UUID, int) []routertypes.RepairResponse); ok {
		r0 = rf(ctx, className, shardName, initialUUID, finalUUID, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]routertypes.RepairResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, strfmt.UUID, strfmt.UUID, int) error); ok {
		r1 = rf(ctx, className, shardName, initialUUID, finalUUID, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockReplicator_DigestObjectsInRange_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DigestObjectsInRange'
type MockReplicator_DigestObjectsInRange_Call struct {
	*mock.Call
}

// DigestObjectsInRange is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - initialUUID strfmt.UUID
//   - finalUUID strfmt.UUID
//   - limit int
func (_e *MockReplicator_Expecter) DigestObjectsInRange(ctx interface{}, className interface{}, shardName interface{}, initialUUID interface{}, finalUUID interface{}, limit interface{}) *MockReplicator_DigestObjectsInRange_Call {
	return &MockReplicator_DigestObjectsInRange_Call{Call: _e.mock.On("DigestObjectsInRange", ctx, className, shardName, initialUUID, finalUUID, limit)}
}

func (_c *MockReplicator_DigestObjectsInRange_Call) Run(run func(ctx context.Context, className string, shardName string, initialUUID strfmt.UUID, finalUUID strfmt.UUID, limit int)) *MockReplicator_DigestObjectsInRange_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(strfmt.UUID), args[4].(strfmt.UUID), args[5].(int))
	})
	return _c
}

func (_c *MockReplicator_DigestObjectsInRange_Call) Return(result []routertypes.RepairResponse, err error) *MockReplicator_DigestObjectsInRange_Call {
	_c.Call.Return(result, err)
	return _c
}

func (_c *MockReplicator_DigestObjectsInRange_Call) RunAndReturn(run func(context.Context, string, string, strfmt.UUID, strfmt.UUID, int) ([]routertypes.RepairResponse, error)) *MockReplicator_DigestObjectsInRange_Call {
	_c.Call.Return(run)
	return _c
}

// FetchObject provides a mock function with given fields: ctx, className, shardName, id
func (_m *MockReplicator) FetchObject(ctx context.Context, className string, shardName string, id strfmt.UUID) (replica.Replica, error) {
	ret := _m.Called(ctx, className, shardName, id)

	if len(ret) == 0 {
		panic("no return value specified for FetchObject")
	}

	var r0 replica.Replica
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, strfmt.UUID) (replica.Replica, error)); ok {
		return rf(ctx, className, shardName, id)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, strfmt.UUID) replica.Replica); ok {
		r0 = rf(ctx, className, shardName, id)
	} else {
		r0 = ret.Get(0).(replica.Replica)
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, strfmt.UUID) error); ok {
		r1 = rf(ctx, className, shardName, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockReplicator_FetchObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchObject'
type MockReplicator_FetchObject_Call struct {
	*mock.Call
}

// FetchObject is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - id strfmt.UUID
func (_e *MockReplicator_Expecter) FetchObject(ctx interface{}, className interface{}, shardName interface{}, id interface{}) *MockReplicator_FetchObject_Call {
	return &MockReplicator_FetchObject_Call{Call: _e.mock.On("FetchObject", ctx, className, shardName, id)}
}

func (_c *MockReplicator_FetchObject_Call) Run(run func(ctx context.Context, className string, shardName string, id strfmt.UUID)) *MockReplicator_FetchObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(strfmt.UUID))
	})
	return _c
}

func (_c *MockReplicator_FetchObject_Call) Return(_a0 replica.Replica, _a1 error) *MockReplicator_FetchObject_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockReplicator_FetchObject_Call) RunAndReturn(run func(context.Context, string, string, strfmt.UUID) (replica.Replica, error)) *MockReplicator_FetchObject_Call {
	_c.Call.Return(run)
	return _c
}

// FetchObjects provides a mock function with given fields: ctx, className, shardName, ids
func (_m *MockReplicator) FetchObjects(ctx context.Context, className string, shardName string, ids []strfmt.UUID) ([]replica.Replica, error) {
	ret := _m.Called(ctx, className, shardName, ids)

	if len(ret) == 0 {
		panic("no return value specified for FetchObjects")
	}

	var r0 []replica.Replica
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []strfmt.UUID) ([]replica.Replica, error)); ok {
		return rf(ctx, className, shardName, ids)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []strfmt.UUID) []replica.Replica); ok {
		r0 = rf(ctx, className, shardName, ids)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]replica.Replica)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, []strfmt.UUID) error); ok {
		r1 = rf(ctx, className, shardName, ids)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockReplicator_FetchObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchObjects'
type MockReplicator_FetchObjects_Call struct {
	*mock.Call
}

// FetchObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - ids []strfmt.UUID
func (_e *MockReplicator_Expecter) FetchObjects(ctx interface{}, className interface{}, shardName interface{}, ids interface{}) *MockReplicator_FetchObjects_Call {
	return &MockReplicator_FetchObjects_Call{Call: _e.mock.On("FetchObjects", ctx, className, shardName, ids)}
}

func (_c *MockReplicator_FetchObjects_Call) Run(run func(ctx context.Context, className string, shardName string, ids []strfmt.UUID)) *MockReplicator_FetchObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]strfmt.UUID))
	})
	return _c
}

func (_c *MockReplicator_FetchObjects_Call) Return(_a0 []replica.Replica, _a1 error) *MockReplicator_FetchObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockReplicator_FetchObjects_Call) RunAndReturn(run func(context.Context, string, string, []strfmt.UUID) ([]replica.Replica, error)) *MockReplicator_FetchObjects_Call {
	_c.Call.Return(run)
	return _c
}

// HashTreeLevel provides a mock function with given fields: ctx, className, shardName, level, discriminant
func (_m *MockReplicator) HashTreeLevel(ctx context.Context, className string, shardName string, level int, discriminant *hashtree.Bitset) ([]hashtree.Digest, error) {
	ret := _m.Called(ctx, className, shardName, level, discriminant)

	if len(ret) == 0 {
		panic("no return value specified for HashTreeLevel")
	}

	var r0 []hashtree.Digest
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, int, *hashtree.Bitset) ([]hashtree.Digest, error)); ok {
		return rf(ctx, className, shardName, level, discriminant)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, int, *hashtree.Bitset) []hashtree.Digest); ok {
		r0 = rf(ctx, className, shardName, level, discriminant)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]hashtree.Digest)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, int, *hashtree.Bitset) error); ok {
		r1 = rf(ctx, className, shardName, level, discriminant)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockReplicator_HashTreeLevel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HashTreeLevel'
type MockReplicator_HashTreeLevel_Call struct {
	*mock.Call
}

// HashTreeLevel is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - level int
//   - discriminant *hashtree.Bitset
func (_e *MockReplicator_Expecter) HashTreeLevel(ctx interface{}, className interface{}, shardName interface{}, level interface{}, discriminant interface{}) *MockReplicator_HashTreeLevel_Call {
	return &MockReplicator_HashTreeLevel_Call{Call: _e.mock.On("HashTreeLevel", ctx, className, shardName, level, discriminant)}
}

func (_c *MockReplicator_HashTreeLevel_Call) Run(run func(ctx context.Context, className string, shardName string, level int, discriminant *hashtree.Bitset)) *MockReplicator_HashTreeLevel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int), args[4].(*hashtree.Bitset))
	})
	return _c
}

func (_c *MockReplicator_HashTreeLevel_Call) Return(digests []hashtree.Digest, err error) *MockReplicator_HashTreeLevel_Call {
	_c.Call.Return(digests, err)
	return _c
}

func (_c *MockReplicator_HashTreeLevel_Call) RunAndReturn(run func(context.Context, string, string, int, *hashtree.Bitset) ([]hashtree.Digest, error)) *MockReplicator_HashTreeLevel_Call {
	_c.Call.Return(run)
	return _c
}

// OverwriteObjects provides a mock function with given fields: ctx, className, shard, vobjects
func (_m *MockReplicator) OverwriteObjects(ctx context.Context, className string, shard string, vobjects []*objects.VObject) ([]routertypes.RepairResponse, error) {
	ret := _m.Called(ctx, className, shard, vobjects)

	if len(ret) == 0 {
		panic("no return value specified for OverwriteObjects")
	}

	var r0 []routertypes.RepairResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []*objects.VObject) ([]routertypes.RepairResponse, error)); ok {
		return rf(ctx, className, shard, vobjects)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, string, []*objects.VObject) []routertypes.RepairResponse); ok {
		r0 = rf(ctx, className, shard, vobjects)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]routertypes.RepairResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, string, []*objects.VObject) error); ok {
		r1 = rf(ctx, className, shard, vobjects)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// MockReplicator_OverwriteObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OverwriteObjects'
type MockReplicator_OverwriteObjects_Call struct {
	*mock.Call
}

// OverwriteObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shard string
//   - vobjects []*objects.VObject
func (_e *MockReplicator_Expecter) OverwriteObjects(ctx interface{}, className interface{}, shard interface{}, vobjects interface{}) *MockReplicator_OverwriteObjects_Call {
	return &MockReplicator_OverwriteObjects_Call{Call: _e.mock.On("OverwriteObjects", ctx, className, shard, vobjects)}
}

func (_c *MockReplicator_OverwriteObjects_Call) Run(run func(ctx context.Context, className string, shard string, vobjects []*objects.VObject)) *MockReplicator_OverwriteObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].([]*objects.VObject))
	})
	return _c
}

func (_c *MockReplicator_OverwriteObjects_Call) Return(_a0 []routertypes.RepairResponse, _a1 error) *MockReplicator_OverwriteObjects_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockReplicator_OverwriteObjects_Call) RunAndReturn(run func(context.Context, string, string, []*objects.VObject) ([]routertypes.RepairResponse, error)) *MockReplicator_OverwriteObjects_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateDeletion provides a mock function with given fields: ctx, className, shardName, requestID, uuid, deletionTime, schemaVersion
func (_m *MockReplicator) ReplicateDeletion(ctx context.Context, className string, shardName string, requestID string, uuid strfmt.UUID, deletionTime time.Time, schemaVersion uint64) replica.SimpleResponse {
	ret := _m.Called(ctx, className, shardName, requestID, uuid, deletionTime, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateDeletion")
	}

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, strfmt.UUID, time.Time, uint64) replica.SimpleResponse); ok {
		r0 = rf(ctx, className, shardName, requestID, uuid, deletionTime, schemaVersion)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

// MockReplicator_ReplicateDeletion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateDeletion'
type MockReplicator_ReplicateDeletion_Call struct {
	*mock.Call
}

// ReplicateDeletion is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - requestID string
//   - uuid strfmt.UUID
//   - deletionTime time.Time
//   - schemaVersion uint64
func (_e *MockReplicator_Expecter) ReplicateDeletion(ctx interface{}, className interface{}, shardName interface{}, requestID interface{}, uuid interface{}, deletionTime interface{}, schemaVersion interface{}) *MockReplicator_ReplicateDeletion_Call {
	return &MockReplicator_ReplicateDeletion_Call{Call: _e.mock.On("ReplicateDeletion", ctx, className, shardName, requestID, uuid, deletionTime, schemaVersion)}
}

func (_c *MockReplicator_ReplicateDeletion_Call) Run(run func(ctx context.Context, className string, shardName string, requestID string, uuid strfmt.UUID, deletionTime time.Time, schemaVersion uint64)) *MockReplicator_ReplicateDeletion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(strfmt.UUID), args[5].(time.Time), args[6].(uint64))
	})
	return _c
}

func (_c *MockReplicator_ReplicateDeletion_Call) Return(_a0 replica.SimpleResponse) *MockReplicator_ReplicateDeletion_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_ReplicateDeletion_Call) RunAndReturn(run func(context.Context, string, string, string, strfmt.UUID, time.Time, uint64) replica.SimpleResponse) *MockReplicator_ReplicateDeletion_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateDeletions provides a mock function with given fields: ctx, className, shardName, requestID, uuids, deletionTime, dryRun, schemaVersion
func (_m *MockReplicator) ReplicateDeletions(ctx context.Context, className string, shardName string, requestID string, uuids []strfmt.UUID, deletionTime time.Time, dryRun bool, schemaVersion uint64) replica.SimpleResponse {
	ret := _m.Called(ctx, className, shardName, requestID, uuids, deletionTime, dryRun, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateDeletions")
	}

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, []strfmt.UUID, time.Time, bool, uint64) replica.SimpleResponse); ok {
		r0 = rf(ctx, className, shardName, requestID, uuids, deletionTime, dryRun, schemaVersion)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

// MockReplicator_ReplicateDeletions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateDeletions'
type MockReplicator_ReplicateDeletions_Call struct {
	*mock.Call
}

// ReplicateDeletions is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - requestID string
//   - uuids []strfmt.UUID
//   - deletionTime time.Time
//   - dryRun bool
//   - schemaVersion uint64
func (_e *MockReplicator_Expecter) ReplicateDeletions(ctx interface{}, className interface{}, shardName interface{}, requestID interface{}, uuids interface{}, deletionTime interface{}, dryRun interface{}, schemaVersion interface{}) *MockReplicator_ReplicateDeletions_Call {
	return &MockReplicator_ReplicateDeletions_Call{Call: _e.mock.On("ReplicateDeletions", ctx, className, shardName, requestID, uuids, deletionTime, dryRun, schemaVersion)}
}

func (_c *MockReplicator_ReplicateDeletions_Call) Run(run func(ctx context.Context, className string, shardName string, requestID string, uuids []strfmt.UUID, deletionTime time.Time, dryRun bool, schemaVersion uint64)) *MockReplicator_ReplicateDeletions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].([]strfmt.UUID), args[5].(time.Time), args[6].(bool), args[7].(uint64))
	})
	return _c
}

func (_c *MockReplicator_ReplicateDeletions_Call) Return(_a0 replica.SimpleResponse) *MockReplicator_ReplicateDeletions_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_ReplicateDeletions_Call) RunAndReturn(run func(context.Context, string, string, string, []strfmt.UUID, time.Time, bool, uint64) replica.SimpleResponse) *MockReplicator_ReplicateDeletions_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateObject provides a mock function with given fields: ctx, className, shardName, requestID, object, schemaVersion
func (_m *MockReplicator) ReplicateObject(ctx context.Context, className string, shardName string, requestID string, object *storobj.Object, schemaVersion uint64) replica.SimpleResponse {
	ret := _m.Called(ctx, className, shardName, requestID, object, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateObject")
	}

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *storobj.Object, uint64) replica.SimpleResponse); ok {
		r0 = rf(ctx, className, shardName, requestID, object, schemaVersion)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

// MockReplicator_ReplicateObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateObject'
type MockReplicator_ReplicateObject_Call struct {
	*mock.Call
}

// ReplicateObject is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - requestID string
//   - object *storobj.Object
//   - schemaVersion uint64
func (_e *MockReplicator_Expecter) ReplicateObject(ctx interface{}, className interface{}, shardName interface{}, requestID interface{}, object interface{}, schemaVersion interface{}) *MockReplicator_ReplicateObject_Call {
	return &MockReplicator_ReplicateObject_Call{Call: _e.mock.On("ReplicateObject", ctx, className, shardName, requestID, object, schemaVersion)}
}

func (_c *MockReplicator_ReplicateObject_Call) Run(run func(ctx context.Context, className string, shardName string, requestID string, object *storobj.Object, schemaVersion uint64)) *MockReplicator_ReplicateObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*storobj.Object), args[5].(uint64))
	})
	return _c
}

func (_c *MockReplicator_ReplicateObject_Call) Return(_a0 replica.SimpleResponse) *MockReplicator_ReplicateObject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_ReplicateObject_Call) RunAndReturn(run func(context.Context, string, string, string, *storobj.Object, uint64) replica.SimpleResponse) *MockReplicator_ReplicateObject_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateObjects provides a mock function with given fields: ctx, className, shardName, requestID, _a4, schemaVersion
func (_m *MockReplicator) ReplicateObjects(ctx context.Context, className string, shardName string, requestID string, _a4 []*storobj.Object, schemaVersion uint64) replica.SimpleResponse {
	ret := _m.Called(ctx, className, shardName, requestID, _a4, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateObjects")
	}

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, []*storobj.Object, uint64) replica.SimpleResponse); ok {
		r0 = rf(ctx, className, shardName, requestID, _a4, schemaVersion)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

// MockReplicator_ReplicateObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateObjects'
type MockReplicator_ReplicateObjects_Call struct {
	*mock.Call
}

// ReplicateObjects is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - requestID string
//   - _a4 []*storobj.Object
//   - schemaVersion uint64
func (_e *MockReplicator_Expecter) ReplicateObjects(ctx interface{}, className interface{}, shardName interface{}, requestID interface{}, _a4 interface{}, schemaVersion interface{}) *MockReplicator_ReplicateObjects_Call {
	return &MockReplicator_ReplicateObjects_Call{Call: _e.mock.On("ReplicateObjects", ctx, className, shardName, requestID, _a4, schemaVersion)}
}

func (_c *MockReplicator_ReplicateObjects_Call) Run(run func(ctx context.Context, className string, shardName string, requestID string, _a4 []*storobj.Object, schemaVersion uint64)) *MockReplicator_ReplicateObjects_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].([]*storobj.Object), args[5].(uint64))
	})
	return _c
}

func (_c *MockReplicator_ReplicateObjects_Call) Return(_a0 replica.SimpleResponse) *MockReplicator_ReplicateObjects_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_ReplicateObjects_Call) RunAndReturn(run func(context.Context, string, string, string, []*storobj.Object, uint64) replica.SimpleResponse) *MockReplicator_ReplicateObjects_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateReferences provides a mock function with given fields: ctx, className, shardName, requestID, refs, schemaVersion
func (_m *MockReplicator) ReplicateReferences(ctx context.Context, className string, shardName string, requestID string, refs []objects.BatchReference, schemaVersion uint64) replica.SimpleResponse {
	ret := _m.Called(ctx, className, shardName, requestID, refs, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateReferences")
	}

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, []objects.BatchReference, uint64) replica.SimpleResponse); ok {
		r0 = rf(ctx, className, shardName, requestID, refs, schemaVersion)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

// MockReplicator_ReplicateReferences_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateReferences'
type MockReplicator_ReplicateReferences_Call struct {
	*mock.Call
}

// ReplicateReferences is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - requestID string
//   - refs []objects.BatchReference
//   - schemaVersion uint64
func (_e *MockReplicator_Expecter) ReplicateReferences(ctx interface{}, className interface{}, shardName interface{}, requestID interface{}, refs interface{}, schemaVersion interface{}) *MockReplicator_ReplicateReferences_Call {
	return &MockReplicator_ReplicateReferences_Call{Call: _e.mock.On("ReplicateReferences", ctx, className, shardName, requestID, refs, schemaVersion)}
}

func (_c *MockReplicator_ReplicateReferences_Call) Run(run func(ctx context.Context, className string, shardName string, requestID string, refs []objects.BatchReference, schemaVersion uint64)) *MockReplicator_ReplicateReferences_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].([]objects.BatchReference), args[5].(uint64))
	})
	return _c
}

func (_c *MockReplicator_ReplicateReferences_Call) Return(_a0 replica.SimpleResponse) *MockReplicator_ReplicateReferences_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_ReplicateReferences_Call) RunAndReturn(run func(context.Context, string, string, string, []objects.BatchReference, uint64) replica.SimpleResponse) *MockReplicator_ReplicateReferences_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateUpdate provides a mock function with given fields: ctx, className, shardName, requestID, mergeDoc, schemaVersion
func (_m *MockReplicator) ReplicateUpdate(ctx context.Context, className string, shardName string, requestID string, mergeDoc *objects.MergeDocument, schemaVersion uint64) replica.SimpleResponse {
	ret := _m.Called(ctx, className, shardName, requestID, mergeDoc, schemaVersion)

	if len(ret) == 0 {
		panic("no return value specified for ReplicateUpdate")
	}

	var r0 replica.SimpleResponse
	if rf, ok := ret.Get(0).(func(context.Context, string, string, string, *objects.MergeDocument, uint64) replica.SimpleResponse); ok {
		r0 = rf(ctx, className, shardName, requestID, mergeDoc, schemaVersion)
	} else {
		r0 = ret.Get(0).(replica.SimpleResponse)
	}

	return r0
}

// MockReplicator_ReplicateUpdate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateUpdate'
type MockReplicator_ReplicateUpdate_Call struct {
	*mock.Call
}

// ReplicateUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - className string
//   - shardName string
//   - requestID string
//   - mergeDoc *objects.MergeDocument
//   - schemaVersion uint64
func (_e *MockReplicator_Expecter) ReplicateUpdate(ctx interface{}, className interface{}, shardName interface{}, requestID interface{}, mergeDoc interface{}, schemaVersion interface{}) *MockReplicator_ReplicateUpdate_Call {
	return &MockReplicator_ReplicateUpdate_Call{Call: _e.mock.On("ReplicateUpdate", ctx, className, shardName, requestID, mergeDoc, schemaVersion)}
}

func (_c *MockReplicator_ReplicateUpdate_Call) Run(run func(ctx context.Context, className string, shardName string, requestID string, mergeDoc *objects.MergeDocument, schemaVersion uint64)) *MockReplicator_ReplicateUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(string), args[4].(*objects.MergeDocument), args[5].(uint64))
	})
	return _c
}

func (_c *MockReplicator_ReplicateUpdate_Call) Return(_a0 replica.SimpleResponse) *MockReplicator_ReplicateUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockReplicator_ReplicateUpdate_Call) RunAndReturn(run func(context.Context, string, string, string, *objects.MergeDocument, uint64) replica.SimpleResponse) *MockReplicator_ReplicateUpdate_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockReplicator creates a new instance of MockReplicator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockReplicator(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReplicator {
	mock := &MockReplicator{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
