search-go/mocks/meilisearch_document_manager_mock.go

// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package mocks

import (
	"context"
	"io"

	"github.com/hanzoai/search-go"
	mock "github.com/stretchr/testify/mock"
)

// NewMockmeilisearchDocumentManager creates a new instance of MockmeilisearchDocumentManager. 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 NewMockmeilisearchDocumentManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockmeilisearchDocumentManager {
	mock := &MockmeilisearchDocumentManager{}
	mock.Mock.Test(t)

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

	return mock
}

// MockmeilisearchDocumentManager is an autogenerated mock type for the DocumentManager type
type MockmeilisearchDocumentManager struct {
	mock.Mock
}

type MockmeilisearchDocumentManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockmeilisearchDocumentManager) EXPECT() *MockmeilisearchDocumentManager_Expecter {
	return &MockmeilisearchDocumentManager_Expecter{mock: &_m.Mock}
}

// AddDocuments provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocuments(documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documentsPtr, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(interface{}, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documentsPtr, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(interface{}, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documentsPtr, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(interface{}, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documentsPtr, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocuments is a helper method to define mock.On call
//   - documentsPtr interface{}
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocuments(documentsPtr interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocuments_Call {
	return &MockmeilisearchDocumentManager_AddDocuments_Call{Call: _e.mock.On("AddDocuments", documentsPtr, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocuments_Call) Run(run func(documentsPtr interface{}, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocuments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 interface{}
		if args[0] != nil {
			arg0 = args[0].(interface{})
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocuments_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocuments_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocuments_Call) RunAndReturn(run func(documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocuments_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsv provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsv(documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, options)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, options)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.CsvDocumentsQuery) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(documents, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsv is a helper method to define mock.On call
//   - documents []byte
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsv(documents interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsv_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsv_Call{Call: _e.mock.On("AddDocumentsCsv", documents, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsv_Call) Run(run func(documents []byte, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsv_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 *meilisearch.CsvDocumentsQuery
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsv_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsv_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsv_Call) RunAndReturn(run func(documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsv_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvFromReader provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvFromReader(documents io.Reader, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, options)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(io.Reader, *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, options)
	}
	if returnFunc, ok := ret.Get(0).(func(io.Reader, *meilisearch.CsvDocumentsQuery) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(io.Reader, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(documents, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvFromReader is a helper method to define mock.On call
//   - documents io.Reader
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvFromReader(documents interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call{Call: _e.mock.On("AddDocumentsCsvFromReader", documents, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call) Run(run func(documents io.Reader, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 io.Reader
		if args[0] != nil {
			arg0 = args[0].(io.Reader)
		}
		var arg1 *meilisearch.CsvDocumentsQuery
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call) RunAndReturn(run func(documents io.Reader, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReader_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvFromReaderInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvFromReaderInBatches(documents io.Reader, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, batchSize, options)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(io.Reader, int, *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, batchSize, options)
	}
	if returnFunc, ok := ret.Get(0).(func(io.Reader, int, *meilisearch.CsvDocumentsQuery) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, batchSize, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(io.Reader, int, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(documents, batchSize, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvFromReaderInBatches is a helper method to define mock.On call
//   - documents io.Reader
//   - batchSize int
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvFromReaderInBatches(documents interface{}, batchSize interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call{Call: _e.mock.On("AddDocumentsCsvFromReaderInBatches", documents, batchSize, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call) Run(run func(documents io.Reader, batchSize int, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 io.Reader
		if args[0] != nil {
			arg0 = args[0].(io.Reader)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.CsvDocumentsQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call) RunAndReturn(run func(documents io.Reader, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvFromReaderInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvFromReaderInBatchesWithContext(ctx context.Context, documents io.Reader, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, batchSize, options)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, int, *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, batchSize, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, int, *meilisearch.CsvDocumentsQuery) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, batchSize, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, io.Reader, int, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(ctx, documents, batchSize, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvFromReaderInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents io.Reader
//   - batchSize int
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvFromReaderInBatchesWithContext(ctx interface{}, documents interface{}, batchSize interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call{Call: _e.mock.On("AddDocumentsCsvFromReaderInBatchesWithContext", ctx, documents, batchSize, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call) Run(run func(ctx context.Context, documents io.Reader, batchSize int, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.CsvDocumentsQuery
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documents io.Reader, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvFromReaderWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvFromReaderWithContext(ctx context.Context, documents io.Reader, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, options)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, *meilisearch.CsvDocumentsQuery) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, io.Reader, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(ctx, documents, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvFromReaderWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents io.Reader
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvFromReaderWithContext(ctx interface{}, documents interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call{Call: _e.mock.On("AddDocumentsCsvFromReaderWithContext", ctx, documents, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call) Run(run func(ctx context.Context, documents io.Reader, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 *meilisearch.CsvDocumentsQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call) RunAndReturn(run func(ctx context.Context, documents io.Reader, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvFromReaderWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvInBatches(documents []byte, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, batchSize, options)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, batchSize, options)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.CsvDocumentsQuery) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, batchSize, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, int, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(documents, batchSize, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvInBatches is a helper method to define mock.On call
//   - documents []byte
//   - batchSize int
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvInBatches(documents interface{}, batchSize interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call{Call: _e.mock.On("AddDocumentsCsvInBatches", documents, batchSize, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call) Run(run func(documents []byte, batchSize int, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.CsvDocumentsQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call) RunAndReturn(run func(documents []byte, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvInBatchesWithContext(ctx context.Context, documents []byte, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, batchSize, options)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, batchSize, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.CsvDocumentsQuery) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, batchSize, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, int, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(ctx, documents, batchSize, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - batchSize int
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvInBatchesWithContext(ctx interface{}, documents interface{}, batchSize interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call{Call: _e.mock.On("AddDocumentsCsvInBatchesWithContext", ctx, documents, batchSize, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call) Run(run func(ctx context.Context, documents []byte, batchSize int, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.CsvDocumentsQuery
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, batchSize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsCsvWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsCsvWithContext(ctx context.Context, documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, options)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.CsvDocumentsQuery) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(ctx, documents, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsCsvWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsCsvWithContext(ctx interface{}, documents interface{}, options interface{}) *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call{Call: _e.mock.On("AddDocumentsCsvWithContext", ctx, documents, options)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call) Run(run func(ctx context.Context, documents []byte, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 *meilisearch.CsvDocumentsQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsCsvWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsInBatches(documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documentsPtr, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(interface{}, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documentsPtr, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(interface{}, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documentsPtr, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(interface{}, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documentsPtr, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsInBatches is a helper method to define mock.On call
//   - documentsPtr interface{}
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsInBatches(documentsPtr interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsInBatches_Call{Call: _e.mock.On("AddDocumentsInBatches", documentsPtr, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call) Run(run func(documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 interface{}
		if args[0] != nil {
			arg0 = args[0].(interface{})
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call) RunAndReturn(run func(documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsInBatchesWithContext(ctx context.Context, documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documentsPtr, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documentsPtr, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documentsPtr, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, interface{}, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documentsPtr, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documentsPtr interface{}
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsInBatchesWithContext(ctx interface{}, documentsPtr interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call{Call: _e.mock.On("AddDocumentsInBatchesWithContext", ctx, documentsPtr, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call) Run(run func(ctx context.Context, documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 interface{}
		if args[1] != nil {
			arg1 = args[1].(interface{})
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.DocumentOptions
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjson provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjson(documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, opts)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documents, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjson is a helper method to define mock.On call
//   - documents []byte
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjson(documents interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjson_Call{Call: _e.mock.On("AddDocumentsNdjson", documents, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call) Run(run func(documents []byte, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call) RunAndReturn(run func(documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjson_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonFromReader provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonFromReader(documents io.Reader, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(io.Reader, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(io.Reader, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(io.Reader, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documents, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonFromReader is a helper method to define mock.On call
//   - documents io.Reader
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonFromReader(documents interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call{Call: _e.mock.On("AddDocumentsNdjsonFromReader", documents, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call) Run(run func(documents io.Reader, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 io.Reader
		if args[0] != nil {
			arg0 = args[0].(io.Reader)
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call) RunAndReturn(run func(documents io.Reader, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReader_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonFromReaderInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonFromReaderInBatches(documents io.Reader, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(io.Reader, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(io.Reader, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(io.Reader, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documents, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonFromReaderInBatches is a helper method to define mock.On call
//   - documents io.Reader
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonFromReaderInBatches(documents interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call{Call: _e.mock.On("AddDocumentsNdjsonFromReaderInBatches", documents, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call) Run(run func(documents io.Reader, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 io.Reader
		if args[0] != nil {
			arg0 = args[0].(io.Reader)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call) RunAndReturn(run func(documents io.Reader, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonFromReaderInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonFromReaderInBatchesWithContext(ctx context.Context, documents io.Reader, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, io.Reader, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documents, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonFromReaderInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents io.Reader
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonFromReaderInBatchesWithContext(ctx interface{}, documents interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call{Call: _e.mock.On("AddDocumentsNdjsonFromReaderInBatchesWithContext", ctx, documents, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call) Run(run func(ctx context.Context, documents io.Reader, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.DocumentOptions
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documents io.Reader, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonFromReaderWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonFromReaderWithContext(ctx context.Context, documents io.Reader, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, io.Reader, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, io.Reader, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documents, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonFromReaderWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents io.Reader
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonFromReaderWithContext(ctx interface{}, documents interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call{Call: _e.mock.On("AddDocumentsNdjsonFromReaderWithContext", ctx, documents, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call) Run(run func(ctx context.Context, documents io.Reader, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 io.Reader
		if args[1] != nil {
			arg1 = args[1].(io.Reader)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call) RunAndReturn(run func(ctx context.Context, documents io.Reader, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonFromReaderWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonInBatches(documents []byte, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documents, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonInBatches is a helper method to define mock.On call
//   - documents []byte
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonInBatches(documents interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call{Call: _e.mock.On("AddDocumentsNdjsonInBatches", documents, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call) Run(run func(documents []byte, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call) RunAndReturn(run func(documents []byte, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonInBatchesWithContext(ctx context.Context, documents []byte, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documents, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonInBatchesWithContext(ctx interface{}, documents interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call{Call: _e.mock.On("AddDocumentsNdjsonInBatchesWithContext", ctx, documents, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call) Run(run func(ctx context.Context, documents []byte, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.DocumentOptions
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsNdjsonWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsNdjsonWithContext(ctx context.Context, documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documents, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsNdjsonWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsNdjsonWithContext(ctx interface{}, documents interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call{Call: _e.mock.On("AddDocumentsNdjsonWithContext", ctx, documents, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call) Run(run func(ctx context.Context, documents []byte, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsNdjsonWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocumentsWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) AddDocumentsWithContext(ctx context.Context, documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documentsPtr, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documentsPtr, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documentsPtr, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, interface{}, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documentsPtr, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// AddDocumentsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documentsPtr interface{}
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) AddDocumentsWithContext(ctx interface{}, documentsPtr interface{}, opts interface{}) *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call {
	return &MockmeilisearchDocumentManager_AddDocumentsWithContext_Call{Call: _e.mock.On("AddDocumentsWithContext", ctx, documentsPtr, opts)}
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call) Run(run func(ctx context.Context, documentsPtr interface{}, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 interface{}
		if args[1] != nil {
			arg1 = args[1].(interface{})
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call) RunAndReturn(run func(ctx context.Context, documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_AddDocumentsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAllDocuments provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteAllDocuments(opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(opts)
	}
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteAllDocuments is a helper method to define mock.On call
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteAllDocuments(opts interface{}) *MockmeilisearchDocumentManager_DeleteAllDocuments_Call {
	return &MockmeilisearchDocumentManager_DeleteAllDocuments_Call{Call: _e.mock.On("DeleteAllDocuments", opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteAllDocuments_Call) Run(run func(opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteAllDocuments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *meilisearch.DocumentOptions
		if args[0] != nil {
			arg0 = args[0].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteAllDocuments_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteAllDocuments_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteAllDocuments_Call) RunAndReturn(run func(opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteAllDocuments_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteAllDocumentsWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteAllDocumentsWithContext(ctx context.Context, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteAllDocumentsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteAllDocumentsWithContext(ctx interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call {
	return &MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call{Call: _e.mock.On("DeleteAllDocumentsWithContext", ctx, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call) Run(run func(ctx context.Context, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call) RunAndReturn(run func(ctx context.Context, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteAllDocumentsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDocument provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteDocument(identifier string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(identifier, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(identifier, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(string, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(identifier, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(identifier, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDocument is a helper method to define mock.On call
//   - identifier string
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteDocument(identifier interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteDocument_Call {
	return &MockmeilisearchDocumentManager_DeleteDocument_Call{Call: _e.mock.On("DeleteDocument", identifier, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteDocument_Call) Run(run func(identifier string, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteDocument_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocument_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteDocument_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocument_Call) RunAndReturn(run func(identifier string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteDocument_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDocumentWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteDocumentWithContext(ctx context.Context, identifier string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, identifier, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, identifier, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, identifier, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, identifier, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDocumentWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - identifier string
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteDocumentWithContext(ctx interface{}, identifier interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call {
	return &MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call{Call: _e.mock.On("DeleteDocumentWithContext", ctx, identifier, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call) Run(run func(ctx context.Context, identifier string, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call) RunAndReturn(run func(ctx context.Context, identifier string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteDocumentWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDocuments provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteDocuments(identifiers []string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(identifiers, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]string, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(identifiers, opts)
	}
	if returnFunc, ok := ret.Get(0).(func([]string, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(identifiers, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]string, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(identifiers, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDocuments is a helper method to define mock.On call
//   - identifiers []string
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteDocuments(identifiers interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteDocuments_Call {
	return &MockmeilisearchDocumentManager_DeleteDocuments_Call{Call: _e.mock.On("DeleteDocuments", identifiers, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteDocuments_Call) Run(run func(identifiers []string, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteDocuments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []string
		if args[0] != nil {
			arg0 = args[0].([]string)
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocuments_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteDocuments_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocuments_Call) RunAndReturn(run func(identifiers []string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteDocuments_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDocumentsByFilter provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteDocumentsByFilter(filter interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(filter, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(interface{}, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(filter, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(interface{}, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(filter, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(interface{}, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(filter, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDocumentsByFilter is a helper method to define mock.On call
//   - filter interface{}
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteDocumentsByFilter(filter interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call {
	return &MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call{Call: _e.mock.On("DeleteDocumentsByFilter", filter, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call) Run(run func(filter interface{}, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 interface{}
		if args[0] != nil {
			arg0 = args[0].(interface{})
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call) RunAndReturn(run func(filter interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteDocumentsByFilter_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDocumentsByFilterWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteDocumentsByFilterWithContext(ctx context.Context, filter interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, filter, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, filter, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, filter, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, interface{}, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, filter, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDocumentsByFilterWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - filter interface{}
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteDocumentsByFilterWithContext(ctx interface{}, filter interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call {
	return &MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call{Call: _e.mock.On("DeleteDocumentsByFilterWithContext", ctx, filter, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call) Run(run func(ctx context.Context, filter interface{}, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 interface{}
		if args[1] != nil {
			arg1 = args[1].(interface{})
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call) RunAndReturn(run func(ctx context.Context, filter interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteDocumentsByFilterWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteDocumentsWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) DeleteDocumentsWithContext(ctx context.Context, identifiers []string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, identifiers, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, identifiers, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []string, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, identifiers, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []string, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, identifiers, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// DeleteDocumentsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - identifiers []string
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) DeleteDocumentsWithContext(ctx interface{}, identifiers interface{}, opts interface{}) *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call {
	return &MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call{Call: _e.mock.On("DeleteDocumentsWithContext", ctx, identifiers, opts)}
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call) Run(run func(ctx context.Context, identifiers []string, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []string
		if args[1] != nil {
			arg1 = args[1].([]string)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call) RunAndReturn(run func(ctx context.Context, identifiers []string, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_DeleteDocumentsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocument provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) GetDocument(identifier string, request *meilisearch.DocumentQuery, documentPtr interface{}) error {
	ret := _mock.Called(identifier, request, documentPtr)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(string, *meilisearch.DocumentQuery, interface{}) error); ok {
		r0 = returnFunc(identifier, request, documentPtr)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// GetDocument is a helper method to define mock.On call
//   - identifier string
//   - request *meilisearch.DocumentQuery
//   - documentPtr interface{}
func (_e *MockmeilisearchDocumentManager_Expecter) GetDocument(identifier interface{}, request interface{}, documentPtr interface{}) *MockmeilisearchDocumentManager_GetDocument_Call {
	return &MockmeilisearchDocumentManager_GetDocument_Call{Call: _e.mock.On("GetDocument", identifier, request, documentPtr)}
}

func (_c *MockmeilisearchDocumentManager_GetDocument_Call) Run(run func(identifier string, request *meilisearch.DocumentQuery, documentPtr interface{})) *MockmeilisearchDocumentManager_GetDocument_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		var arg1 *meilisearch.DocumentQuery
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentQuery)
		}
		var arg2 interface{}
		if args[2] != nil {
			arg2 = args[2].(interface{})
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocument_Call) Return(err error) *MockmeilisearchDocumentManager_GetDocument_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocument_Call) RunAndReturn(run func(identifier string, request *meilisearch.DocumentQuery, documentPtr interface{}) error) *MockmeilisearchDocumentManager_GetDocument_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) GetDocumentWithContext(ctx context.Context, identifier string, request *meilisearch.DocumentQuery, documentPtr interface{}) error {
	ret := _mock.Called(ctx, identifier, request, documentPtr)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, *meilisearch.DocumentQuery, interface{}) error); ok {
		r0 = returnFunc(ctx, identifier, request, documentPtr)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// GetDocumentWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - identifier string
//   - request *meilisearch.DocumentQuery
//   - documentPtr interface{}
func (_e *MockmeilisearchDocumentManager_Expecter) GetDocumentWithContext(ctx interface{}, identifier interface{}, request interface{}, documentPtr interface{}) *MockmeilisearchDocumentManager_GetDocumentWithContext_Call {
	return &MockmeilisearchDocumentManager_GetDocumentWithContext_Call{Call: _e.mock.On("GetDocumentWithContext", ctx, identifier, request, documentPtr)}
}

func (_c *MockmeilisearchDocumentManager_GetDocumentWithContext_Call) Run(run func(ctx context.Context, identifier string, request *meilisearch.DocumentQuery, documentPtr interface{})) *MockmeilisearchDocumentManager_GetDocumentWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 *meilisearch.DocumentQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentQuery)
		}
		var arg3 interface{}
		if args[3] != nil {
			arg3 = args[3].(interface{})
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocumentWithContext_Call) Return(err error) *MockmeilisearchDocumentManager_GetDocumentWithContext_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocumentWithContext_Call) RunAndReturn(run func(ctx context.Context, identifier string, request *meilisearch.DocumentQuery, documentPtr interface{}) error) *MockmeilisearchDocumentManager_GetDocumentWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocuments provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) GetDocuments(param *meilisearch.DocumentsQuery, resp *meilisearch.DocumentsResult) error {
	ret := _mock.Called(param, resp)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.DocumentsQuery, *meilisearch.DocumentsResult) error); ok {
		r0 = returnFunc(param, resp)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// GetDocuments is a helper method to define mock.On call
//   - param *meilisearch.DocumentsQuery
//   - resp *meilisearch.DocumentsResult
func (_e *MockmeilisearchDocumentManager_Expecter) GetDocuments(param interface{}, resp interface{}) *MockmeilisearchDocumentManager_GetDocuments_Call {
	return &MockmeilisearchDocumentManager_GetDocuments_Call{Call: _e.mock.On("GetDocuments", param, resp)}
}

func (_c *MockmeilisearchDocumentManager_GetDocuments_Call) Run(run func(param *meilisearch.DocumentsQuery, resp *meilisearch.DocumentsResult)) *MockmeilisearchDocumentManager_GetDocuments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *meilisearch.DocumentsQuery
		if args[0] != nil {
			arg0 = args[0].(*meilisearch.DocumentsQuery)
		}
		var arg1 *meilisearch.DocumentsResult
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentsResult)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocuments_Call) Return(err error) *MockmeilisearchDocumentManager_GetDocuments_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocuments_Call) RunAndReturn(run func(param *meilisearch.DocumentsQuery, resp *meilisearch.DocumentsResult) error) *MockmeilisearchDocumentManager_GetDocuments_Call {
	_c.Call.Return(run)
	return _c
}

// GetDocumentsWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) GetDocumentsWithContext(ctx context.Context, param *meilisearch.DocumentsQuery, resp *meilisearch.DocumentsResult) error {
	ret := _mock.Called(ctx, param, resp)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *meilisearch.DocumentsQuery, *meilisearch.DocumentsResult) error); ok {
		r0 = returnFunc(ctx, param, resp)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// GetDocumentsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - param *meilisearch.DocumentsQuery
//   - resp *meilisearch.DocumentsResult
func (_e *MockmeilisearchDocumentManager_Expecter) GetDocumentsWithContext(ctx interface{}, param interface{}, resp interface{}) *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call {
	return &MockmeilisearchDocumentManager_GetDocumentsWithContext_Call{Call: _e.mock.On("GetDocumentsWithContext", ctx, param, resp)}
}

func (_c *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call) Run(run func(ctx context.Context, param *meilisearch.DocumentsQuery, resp *meilisearch.DocumentsResult)) *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *meilisearch.DocumentsQuery
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentsQuery)
		}
		var arg2 *meilisearch.DocumentsResult
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentsResult)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call) Return(err error) *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call) RunAndReturn(run func(ctx context.Context, param *meilisearch.DocumentsQuery, resp *meilisearch.DocumentsResult) error) *MockmeilisearchDocumentManager_GetDocumentsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocuments provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocuments(documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documentsPtr, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(interface{}, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documentsPtr, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(interface{}, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documentsPtr, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(interface{}, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documentsPtr, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocuments is a helper method to define mock.On call
//   - documentsPtr interface{}
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocuments(documentsPtr interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocuments_Call {
	return &MockmeilisearchDocumentManager_UpdateDocuments_Call{Call: _e.mock.On("UpdateDocuments", documentsPtr, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocuments_Call) Run(run func(documentsPtr interface{}, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocuments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 interface{}
		if args[0] != nil {
			arg0 = args[0].(interface{})
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocuments_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocuments_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocuments_Call) RunAndReturn(run func(documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocuments_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsByFunction provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsByFunction(req *meilisearch.UpdateDocumentByFunctionRequest) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(req)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.UpdateDocumentByFunctionRequest) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(req)
	}
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.UpdateDocumentByFunctionRequest) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*meilisearch.UpdateDocumentByFunctionRequest) error); ok {
		r1 = returnFunc(req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsByFunction is a helper method to define mock.On call
//   - req *meilisearch.UpdateDocumentByFunctionRequest
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsByFunction(req interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call{Call: _e.mock.On("UpdateDocumentsByFunction", req)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call) Run(run func(req *meilisearch.UpdateDocumentByFunctionRequest)) *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 *meilisearch.UpdateDocumentByFunctionRequest
		if args[0] != nil {
			arg0 = args[0].(*meilisearch.UpdateDocumentByFunctionRequest)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call) RunAndReturn(run func(req *meilisearch.UpdateDocumentByFunctionRequest) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsByFunction_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsByFunctionWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsByFunctionWithContext(ctx context.Context, req *meilisearch.UpdateDocumentByFunctionRequest) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, req)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *meilisearch.UpdateDocumentByFunctionRequest) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, req)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, *meilisearch.UpdateDocumentByFunctionRequest) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, *meilisearch.UpdateDocumentByFunctionRequest) error); ok {
		r1 = returnFunc(ctx, req)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsByFunctionWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - req *meilisearch.UpdateDocumentByFunctionRequest
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsByFunctionWithContext(ctx interface{}, req interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call{Call: _e.mock.On("UpdateDocumentsByFunctionWithContext", ctx, req)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call) Run(run func(ctx context.Context, req *meilisearch.UpdateDocumentByFunctionRequest)) *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *meilisearch.UpdateDocumentByFunctionRequest
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.UpdateDocumentByFunctionRequest)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call) RunAndReturn(run func(ctx context.Context, req *meilisearch.UpdateDocumentByFunctionRequest) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsByFunctionWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsCsv provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsCsv(documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, options)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, options)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.CsvDocumentsQuery) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(documents, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsCsv is a helper method to define mock.On call
//   - documents []byte
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsCsv(documents interface{}, options interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call{Call: _e.mock.On("UpdateDocumentsCsv", documents, options)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call) Run(run func(documents []byte, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 *meilisearch.CsvDocumentsQuery
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call) RunAndReturn(run func(documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsCsv_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsCsvInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsCsvInBatches(documents []byte, batchsize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, batchsize, options)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, batchsize, options)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.CsvDocumentsQuery) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, batchsize, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, int, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(documents, batchsize, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsCsvInBatches is a helper method to define mock.On call
//   - documents []byte
//   - batchsize int
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsCsvInBatches(documents interface{}, batchsize interface{}, options interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call{Call: _e.mock.On("UpdateDocumentsCsvInBatches", documents, batchsize, options)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call) Run(run func(documents []byte, batchsize int, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.CsvDocumentsQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call) RunAndReturn(run func(documents []byte, batchsize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsCsvInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsCsvInBatchesWithContext(ctx context.Context, documents []byte, batchsize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, batchsize, options)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, batchsize, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.CsvDocumentsQuery) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, batchsize, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, int, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(ctx, documents, batchsize, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsCsvInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - batchsize int
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsCsvInBatchesWithContext(ctx interface{}, documents interface{}, batchsize interface{}, options interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call{Call: _e.mock.On("UpdateDocumentsCsvInBatchesWithContext", ctx, documents, batchsize, options)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call) Run(run func(ctx context.Context, documents []byte, batchsize int, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.CsvDocumentsQuery
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, batchsize int, options *meilisearch.CsvDocumentsQuery) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsCsvInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsCsvWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsCsvWithContext(ctx context.Context, documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, options)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, options)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.CsvDocumentsQuery) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, options)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, *meilisearch.CsvDocumentsQuery) error); ok {
		r1 = returnFunc(ctx, documents, options)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsCsvWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - options *meilisearch.CsvDocumentsQuery
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsCsvWithContext(ctx interface{}, documents interface{}, options interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call{Call: _e.mock.On("UpdateDocumentsCsvWithContext", ctx, documents, options)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call) Run(run func(ctx context.Context, documents []byte, options *meilisearch.CsvDocumentsQuery)) *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 *meilisearch.CsvDocumentsQuery
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.CsvDocumentsQuery)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, options *meilisearch.CsvDocumentsQuery) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsCsvWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsInBatches(documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documentsPtr, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(interface{}, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documentsPtr, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(interface{}, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documentsPtr, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(interface{}, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documentsPtr, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsInBatches is a helper method to define mock.On call
//   - documentsPtr interface{}
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsInBatches(documentsPtr interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call{Call: _e.mock.On("UpdateDocumentsInBatches", documentsPtr, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call) Run(run func(documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 interface{}
		if args[0] != nil {
			arg0 = args[0].(interface{})
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call) RunAndReturn(run func(documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsInBatchesWithContext(ctx context.Context, documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documentsPtr, batchSize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documentsPtr, batchSize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documentsPtr, batchSize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, interface{}, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documentsPtr, batchSize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documentsPtr interface{}
//   - batchSize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsInBatchesWithContext(ctx interface{}, documentsPtr interface{}, batchSize interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call{Call: _e.mock.On("UpdateDocumentsInBatchesWithContext", ctx, documentsPtr, batchSize, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call) Run(run func(ctx context.Context, documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 interface{}
		if args[1] != nil {
			arg1 = args[1].(interface{})
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.DocumentOptions
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documentsPtr interface{}, batchSize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsNdjson provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsNdjson(documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, opts)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documents, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsNdjson is a helper method to define mock.On call
//   - documents []byte
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsNdjson(documents interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call{Call: _e.mock.On("UpdateDocumentsNdjson", documents, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call) Run(run func(documents []byte, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 *meilisearch.DocumentOptions
		if args[1] != nil {
			arg1 = args[1].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call) RunAndReturn(run func(documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjson_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsNdjsonInBatches provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsNdjsonInBatches(documents []byte, batchsize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(documents, batchsize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(documents, batchsize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func([]byte, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(documents, batchsize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func([]byte, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(documents, batchsize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsNdjsonInBatches is a helper method to define mock.On call
//   - documents []byte
//   - batchsize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsNdjsonInBatches(documents interface{}, batchsize interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call{Call: _e.mock.On("UpdateDocumentsNdjsonInBatches", documents, batchsize, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call) Run(run func(documents []byte, batchsize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 []byte
		if args[0] != nil {
			arg0 = args[0].([]byte)
		}
		var arg1 int
		if args[1] != nil {
			arg1 = args[1].(int)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call) RunAndReturn(run func(documents []byte, batchsize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatches_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsNdjsonInBatchesWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsNdjsonInBatchesWithContext(ctx context.Context, documents []byte, batchsize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, batchsize, opts)

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

	var r0 []meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, batchsize, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, int, *meilisearch.DocumentOptions) []meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, batchsize, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, int, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documents, batchsize, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsNdjsonInBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - batchsize int
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsNdjsonInBatchesWithContext(ctx interface{}, documents interface{}, batchsize interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call{Call: _e.mock.On("UpdateDocumentsNdjsonInBatchesWithContext", ctx, documents, batchsize, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call) Run(run func(ctx context.Context, documents []byte, batchsize int, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 int
		if args[2] != nil {
			arg2 = args[2].(int)
		}
		var arg3 *meilisearch.DocumentOptions
		if args[3] != nil {
			arg3 = args[3].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call) Return(taskInfos []meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call {
	_c.Call.Return(taskInfos, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, batchsize int, opts *meilisearch.DocumentOptions) ([]meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonInBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsNdjsonWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsNdjsonWithContext(ctx context.Context, documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documents, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documents, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, []byte, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documents, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, []byte, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documents, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsNdjsonWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documents []byte
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsNdjsonWithContext(ctx interface{}, documents interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call{Call: _e.mock.On("UpdateDocumentsNdjsonWithContext", ctx, documents, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call) Run(run func(ctx context.Context, documents []byte, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 []byte
		if args[1] != nil {
			arg1 = args[1].([]byte)
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call) RunAndReturn(run func(ctx context.Context, documents []byte, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsNdjsonWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDocumentsWithContext provides a mock function for the type MockmeilisearchDocumentManager
func (_mock *MockmeilisearchDocumentManager) UpdateDocumentsWithContext(ctx context.Context, documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, documentsPtr, opts)

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

	var r0 *meilisearch.TaskInfo
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)); ok {
		return returnFunc(ctx, documentsPtr, opts)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, interface{}, *meilisearch.DocumentOptions) *meilisearch.TaskInfo); ok {
		r0 = returnFunc(ctx, documentsPtr, opts)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*meilisearch.TaskInfo)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, interface{}, *meilisearch.DocumentOptions) error); ok {
		r1 = returnFunc(ctx, documentsPtr, opts)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// UpdateDocumentsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - documentsPtr interface{}
//   - opts *meilisearch.DocumentOptions
func (_e *MockmeilisearchDocumentManager_Expecter) UpdateDocumentsWithContext(ctx interface{}, documentsPtr interface{}, opts interface{}) *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call {
	return &MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call{Call: _e.mock.On("UpdateDocumentsWithContext", ctx, documentsPtr, opts)}
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call) Run(run func(ctx context.Context, documentsPtr interface{}, opts *meilisearch.DocumentOptions)) *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 interface{}
		if args[1] != nil {
			arg1 = args[1].(interface{})
		}
		var arg2 *meilisearch.DocumentOptions
		if args[2] != nil {
			arg2 = args[2].(*meilisearch.DocumentOptions)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call) RunAndReturn(run func(ctx context.Context, documentsPtr interface{}, opts *meilisearch.DocumentOptions) (*meilisearch.TaskInfo, error)) *MockmeilisearchDocumentManager_UpdateDocumentsWithContext_Call {
	_c.Call.Return(run)
	return _c
}