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

package mocks

import (
	"context"

	"github.com/meilisearch/meilisearch-go"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockmeilisearchServiceReader is an autogenerated mock type for the ServiceReader type
type MockmeilisearchServiceReader struct {
	mock.Mock
}

type MockmeilisearchServiceReader_Expecter struct {
	mock *mock.Mock
}

func (_m *MockmeilisearchServiceReader) EXPECT() *MockmeilisearchServiceReader_Expecter {
	return &MockmeilisearchServiceReader_Expecter{mock: &_m.Mock}
}

// GetBatch provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetBatch(batchUID int) (*meilisearch.Batch, error) {
	ret := _mock.Called(batchUID)

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

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

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

// GetBatch is a helper method to define mock.On call
//   - batchUID int
func (_e *MockmeilisearchServiceReader_Expecter) GetBatch(batchUID interface{}) *MockmeilisearchServiceReader_GetBatch_Call {
	return &MockmeilisearchServiceReader_GetBatch_Call{Call: _e.mock.On("GetBatch", batchUID)}
}

func (_c *MockmeilisearchServiceReader_GetBatch_Call) Run(run func(batchUID int)) *MockmeilisearchServiceReader_GetBatch_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 int
		if args[0] != nil {
			arg0 = args[0].(int)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetBatch_Call) Return(batch *meilisearch.Batch, err error) *MockmeilisearchServiceReader_GetBatch_Call {
	_c.Call.Return(batch, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetBatch_Call) RunAndReturn(run func(batchUID int) (*meilisearch.Batch, error)) *MockmeilisearchServiceReader_GetBatch_Call {
	_c.Call.Return(run)
	return _c
}

// GetBatchWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetBatchWithContext(ctx context.Context, batchUID int) (*meilisearch.Batch, error) {
	ret := _mock.Called(ctx, batchUID)

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

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

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

// GetBatchWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - batchUID int
func (_e *MockmeilisearchServiceReader_Expecter) GetBatchWithContext(ctx interface{}, batchUID interface{}) *MockmeilisearchServiceReader_GetBatchWithContext_Call {
	return &MockmeilisearchServiceReader_GetBatchWithContext_Call{Call: _e.mock.On("GetBatchWithContext", ctx, batchUID)}
}

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

func (_c *MockmeilisearchServiceReader_GetBatchWithContext_Call) Return(batch *meilisearch.Batch, err error) *MockmeilisearchServiceReader_GetBatchWithContext_Call {
	_c.Call.Return(batch, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetBatchWithContext_Call) RunAndReturn(run func(ctx context.Context, batchUID int) (*meilisearch.Batch, error)) *MockmeilisearchServiceReader_GetBatchWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetBatches provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetBatches(param *meilisearch.BatchesQuery) (*meilisearch.BatchesResults, error) {
	ret := _mock.Called(param)

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

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

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

// GetBatches is a helper method to define mock.On call
//   - param *meilisearch.BatchesQuery
func (_e *MockmeilisearchServiceReader_Expecter) GetBatches(param interface{}) *MockmeilisearchServiceReader_GetBatches_Call {
	return &MockmeilisearchServiceReader_GetBatches_Call{Call: _e.mock.On("GetBatches", param)}
}

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

func (_c *MockmeilisearchServiceReader_GetBatches_Call) Return(batchesResults *meilisearch.BatchesResults, err error) *MockmeilisearchServiceReader_GetBatches_Call {
	_c.Call.Return(batchesResults, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetBatches_Call) RunAndReturn(run func(param *meilisearch.BatchesQuery) (*meilisearch.BatchesResults, error)) *MockmeilisearchServiceReader_GetBatches_Call {
	_c.Call.Return(run)
	return _c
}

// GetBatchesWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetBatchesWithContext(ctx context.Context, param *meilisearch.BatchesQuery) (*meilisearch.BatchesResults, error) {
	ret := _mock.Called(ctx, param)

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

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

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

// GetBatchesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - param *meilisearch.BatchesQuery
func (_e *MockmeilisearchServiceReader_Expecter) GetBatchesWithContext(ctx interface{}, param interface{}) *MockmeilisearchServiceReader_GetBatchesWithContext_Call {
	return &MockmeilisearchServiceReader_GetBatchesWithContext_Call{Call: _e.mock.On("GetBatchesWithContext", ctx, param)}
}

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

func (_c *MockmeilisearchServiceReader_GetBatchesWithContext_Call) Return(batchesResults *meilisearch.BatchesResults, err error) *MockmeilisearchServiceReader_GetBatchesWithContext_Call {
	_c.Call.Return(batchesResults, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetBatchesWithContext_Call) RunAndReturn(run func(ctx context.Context, param *meilisearch.BatchesQuery) (*meilisearch.BatchesResults, error)) *MockmeilisearchServiceReader_GetBatchesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetIndex provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetIndex(indexID string) (*meilisearch.IndexResult, error) {
	ret := _mock.Called(indexID)

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

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

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

// GetIndex is a helper method to define mock.On call
//   - indexID string
func (_e *MockmeilisearchServiceReader_Expecter) GetIndex(indexID interface{}) *MockmeilisearchServiceReader_GetIndex_Call {
	return &MockmeilisearchServiceReader_GetIndex_Call{Call: _e.mock.On("GetIndex", indexID)}
}

func (_c *MockmeilisearchServiceReader_GetIndex_Call) Run(run func(indexID string)) *MockmeilisearchServiceReader_GetIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetIndex_Call) Return(indexResult *meilisearch.IndexResult, err error) *MockmeilisearchServiceReader_GetIndex_Call {
	_c.Call.Return(indexResult, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetIndex_Call) RunAndReturn(run func(indexID string) (*meilisearch.IndexResult, error)) *MockmeilisearchServiceReader_GetIndex_Call {
	_c.Call.Return(run)
	return _c
}

// GetIndexWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetIndexWithContext(ctx context.Context, indexID string) (*meilisearch.IndexResult, error) {
	ret := _mock.Called(ctx, indexID)

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

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

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

// GetIndexWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - indexID string
func (_e *MockmeilisearchServiceReader_Expecter) GetIndexWithContext(ctx interface{}, indexID interface{}) *MockmeilisearchServiceReader_GetIndexWithContext_Call {
	return &MockmeilisearchServiceReader_GetIndexWithContext_Call{Call: _e.mock.On("GetIndexWithContext", ctx, indexID)}
}

func (_c *MockmeilisearchServiceReader_GetIndexWithContext_Call) Run(run func(ctx context.Context, indexID string)) *MockmeilisearchServiceReader_GetIndexWithContext_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetIndexWithContext_Call) Return(indexResult *meilisearch.IndexResult, err error) *MockmeilisearchServiceReader_GetIndexWithContext_Call {
	_c.Call.Return(indexResult, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetIndexWithContext_Call) RunAndReturn(run func(ctx context.Context, indexID string) (*meilisearch.IndexResult, error)) *MockmeilisearchServiceReader_GetIndexWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetwork provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetNetwork() (*meilisearch.Network, error) {
	ret := _mock.Called()

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

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

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

// GetNetwork is a helper method to define mock.On call
func (_e *MockmeilisearchServiceReader_Expecter) GetNetwork() *MockmeilisearchServiceReader_GetNetwork_Call {
	return &MockmeilisearchServiceReader_GetNetwork_Call{Call: _e.mock.On("GetNetwork")}
}

func (_c *MockmeilisearchServiceReader_GetNetwork_Call) Run(run func()) *MockmeilisearchServiceReader_GetNetwork_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetNetwork_Call) Return(network *meilisearch.Network, err error) *MockmeilisearchServiceReader_GetNetwork_Call {
	_c.Call.Return(network, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetNetwork_Call) RunAndReturn(run func() (*meilisearch.Network, error)) *MockmeilisearchServiceReader_GetNetwork_Call {
	_c.Call.Return(run)
	return _c
}

// GetNetworkWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetNetworkWithContext(ctx context.Context) (*meilisearch.Network, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetNetworkWithContext is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockmeilisearchServiceReader_Expecter) GetNetworkWithContext(ctx interface{}) *MockmeilisearchServiceReader_GetNetworkWithContext_Call {
	return &MockmeilisearchServiceReader_GetNetworkWithContext_Call{Call: _e.mock.On("GetNetworkWithContext", ctx)}
}

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

func (_c *MockmeilisearchServiceReader_GetNetworkWithContext_Call) Return(network *meilisearch.Network, err error) *MockmeilisearchServiceReader_GetNetworkWithContext_Call {
	_c.Call.Return(network, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetNetworkWithContext_Call) RunAndReturn(run func(ctx context.Context) (*meilisearch.Network, error)) *MockmeilisearchServiceReader_GetNetworkWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetRawIndex provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetRawIndex(uid string) (map[string]interface{}, error) {
	ret := _mock.Called(uid)

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

	var r0 map[string]interface{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(string) (map[string]interface{}, error)); ok {
		return returnFunc(uid)
	}
	if returnFunc, ok := ret.Get(0).(func(string) map[string]interface{}); ok {
		r0 = returnFunc(uid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(string) error); ok {
		r1 = returnFunc(uid)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRawIndex is a helper method to define mock.On call
//   - uid string
func (_e *MockmeilisearchServiceReader_Expecter) GetRawIndex(uid interface{}) *MockmeilisearchServiceReader_GetRawIndex_Call {
	return &MockmeilisearchServiceReader_GetRawIndex_Call{Call: _e.mock.On("GetRawIndex", uid)}
}

func (_c *MockmeilisearchServiceReader_GetRawIndex_Call) Run(run func(uid string)) *MockmeilisearchServiceReader_GetRawIndex_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetRawIndex_Call) Return(stringToIfaceVal map[string]interface{}, err error) *MockmeilisearchServiceReader_GetRawIndex_Call {
	_c.Call.Return(stringToIfaceVal, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetRawIndex_Call) RunAndReturn(run func(uid string) (map[string]interface{}, error)) *MockmeilisearchServiceReader_GetRawIndex_Call {
	_c.Call.Return(run)
	return _c
}

// GetRawIndexWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetRawIndexWithContext(ctx context.Context, uid string) (map[string]interface{}, error) {
	ret := _mock.Called(ctx, uid)

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

	var r0 map[string]interface{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (map[string]interface{}, error)); ok {
		return returnFunc(ctx, uid)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) map[string]interface{}); ok {
		r0 = returnFunc(ctx, uid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = returnFunc(ctx, uid)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRawIndexWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - uid string
func (_e *MockmeilisearchServiceReader_Expecter) GetRawIndexWithContext(ctx interface{}, uid interface{}) *MockmeilisearchServiceReader_GetRawIndexWithContext_Call {
	return &MockmeilisearchServiceReader_GetRawIndexWithContext_Call{Call: _e.mock.On("GetRawIndexWithContext", ctx, uid)}
}

func (_c *MockmeilisearchServiceReader_GetRawIndexWithContext_Call) Run(run func(ctx context.Context, uid string)) *MockmeilisearchServiceReader_GetRawIndexWithContext_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)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetRawIndexWithContext_Call) Return(stringToIfaceVal map[string]interface{}, err error) *MockmeilisearchServiceReader_GetRawIndexWithContext_Call {
	_c.Call.Return(stringToIfaceVal, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetRawIndexWithContext_Call) RunAndReturn(run func(ctx context.Context, uid string) (map[string]interface{}, error)) *MockmeilisearchServiceReader_GetRawIndexWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetRawIndexes provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetRawIndexes(param *meilisearch.IndexesQuery) (map[string]interface{}, error) {
	ret := _mock.Called(param)

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

	var r0 map[string]interface{}
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.IndexesQuery) (map[string]interface{}, error)); ok {
		return returnFunc(param)
	}
	if returnFunc, ok := ret.Get(0).(func(*meilisearch.IndexesQuery) map[string]interface{}); ok {
		r0 = returnFunc(param)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]interface{})
		}
	}
	if returnFunc, ok := ret.Get(1).(func(*meilisearch.IndexesQuery) error); ok {
		r1 = returnFunc(param)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// GetRawIndexes is a helper method to define mock.On call
//   - param *meilisearch.IndexesQuery
func (_e *MockmeilisearchServiceReader_Expecter) GetRawIndexes(param interface{}) *MockmeilisearchServiceReader_GetRawIndexes_Call {
	return &MockmeilisearchServiceReader_GetRawIndexes_Call{Call: _e.mock.On("GetRawIndexes", param)}
}

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

func (_c *MockmeilisearchServiceReader_GetRawIndexes_Call) Return(stringToIfaceVal map[string]interface{}, err error) *MockmeilisearchServiceReader_GetRawIndexes_Call {
	_c.Call.Return(stringToIfaceVal, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetRawIndexes_Call) RunAndReturn(run func(param *meilisearch.IndexesQuery) (map[string]interface{}, error)) *MockmeilisearchServiceReader_GetRawIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// GetRawIndexesWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetRawIndexesWithContext(ctx context.Context, param *meilisearch.IndexesQuery) (map[string]interface{}, error) {
	ret := _mock.Called(ctx, param)

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

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

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

// GetRawIndexesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - param *meilisearch.IndexesQuery
func (_e *MockmeilisearchServiceReader_Expecter) GetRawIndexesWithContext(ctx interface{}, param interface{}) *MockmeilisearchServiceReader_GetRawIndexesWithContext_Call {
	return &MockmeilisearchServiceReader_GetRawIndexesWithContext_Call{Call: _e.mock.On("GetRawIndexesWithContext", ctx, param)}
}

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

func (_c *MockmeilisearchServiceReader_GetRawIndexesWithContext_Call) Return(stringToIfaceVal map[string]interface{}, err error) *MockmeilisearchServiceReader_GetRawIndexesWithContext_Call {
	_c.Call.Return(stringToIfaceVal, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetRawIndexesWithContext_Call) RunAndReturn(run func(ctx context.Context, param *meilisearch.IndexesQuery) (map[string]interface{}, error)) *MockmeilisearchServiceReader_GetRawIndexesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetStats provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetStats() (*meilisearch.Stats, error) {
	ret := _mock.Called()

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

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

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

// GetStats is a helper method to define mock.On call
func (_e *MockmeilisearchServiceReader_Expecter) GetStats() *MockmeilisearchServiceReader_GetStats_Call {
	return &MockmeilisearchServiceReader_GetStats_Call{Call: _e.mock.On("GetStats")}
}

func (_c *MockmeilisearchServiceReader_GetStats_Call) Run(run func()) *MockmeilisearchServiceReader_GetStats_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_GetStats_Call) Return(stats *meilisearch.Stats, err error) *MockmeilisearchServiceReader_GetStats_Call {
	_c.Call.Return(stats, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetStats_Call) RunAndReturn(run func() (*meilisearch.Stats, error)) *MockmeilisearchServiceReader_GetStats_Call {
	_c.Call.Return(run)
	return _c
}

// GetStatsWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) GetStatsWithContext(ctx context.Context) (*meilisearch.Stats, error) {
	ret := _mock.Called(ctx)

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

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

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

// GetStatsWithContext is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockmeilisearchServiceReader_Expecter) GetStatsWithContext(ctx interface{}) *MockmeilisearchServiceReader_GetStatsWithContext_Call {
	return &MockmeilisearchServiceReader_GetStatsWithContext_Call{Call: _e.mock.On("GetStatsWithContext", ctx)}
}

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

func (_c *MockmeilisearchServiceReader_GetStatsWithContext_Call) Return(stats *meilisearch.Stats, err error) *MockmeilisearchServiceReader_GetStatsWithContext_Call {
	_c.Call.Return(stats, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_GetStatsWithContext_Call) RunAndReturn(run func(ctx context.Context) (*meilisearch.Stats, error)) *MockmeilisearchServiceReader_GetStatsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// Health provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) Health() (*meilisearch.Health, error) {
	ret := _mock.Called()

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

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

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

// Health is a helper method to define mock.On call
func (_e *MockmeilisearchServiceReader_Expecter) Health() *MockmeilisearchServiceReader_Health_Call {
	return &MockmeilisearchServiceReader_Health_Call{Call: _e.mock.On("Health")}
}

func (_c *MockmeilisearchServiceReader_Health_Call) Run(run func()) *MockmeilisearchServiceReader_Health_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_Health_Call) Return(health *meilisearch.Health, err error) *MockmeilisearchServiceReader_Health_Call {
	_c.Call.Return(health, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_Health_Call) RunAndReturn(run func() (*meilisearch.Health, error)) *MockmeilisearchServiceReader_Health_Call {
	_c.Call.Return(run)
	return _c
}

// HealthWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) HealthWithContext(ctx context.Context) (*meilisearch.Health, error) {
	ret := _mock.Called(ctx)

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

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

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

// HealthWithContext is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockmeilisearchServiceReader_Expecter) HealthWithContext(ctx interface{}) *MockmeilisearchServiceReader_HealthWithContext_Call {
	return &MockmeilisearchServiceReader_HealthWithContext_Call{Call: _e.mock.On("HealthWithContext", ctx)}
}

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

func (_c *MockmeilisearchServiceReader_HealthWithContext_Call) Return(health *meilisearch.Health, err error) *MockmeilisearchServiceReader_HealthWithContext_Call {
	_c.Call.Return(health, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_HealthWithContext_Call) RunAndReturn(run func(ctx context.Context) (*meilisearch.Health, error)) *MockmeilisearchServiceReader_HealthWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// Index provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) Index(uid string) meilisearch.IndexManager {
	ret := _mock.Called(uid)

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

	var r0 meilisearch.IndexManager
	if returnFunc, ok := ret.Get(0).(func(string) meilisearch.IndexManager); ok {
		r0 = returnFunc(uid)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(meilisearch.IndexManager)
		}
	}
	return r0
}

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

// Index is a helper method to define mock.On call
//   - uid string
func (_e *MockmeilisearchServiceReader_Expecter) Index(uid interface{}) *MockmeilisearchServiceReader_Index_Call {
	return &MockmeilisearchServiceReader_Index_Call{Call: _e.mock.On("Index", uid)}
}

func (_c *MockmeilisearchServiceReader_Index_Call) Run(run func(uid string)) *MockmeilisearchServiceReader_Index_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 string
		if args[0] != nil {
			arg0 = args[0].(string)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_Index_Call) Return(indexManager meilisearch.IndexManager) *MockmeilisearchServiceReader_Index_Call {
	_c.Call.Return(indexManager)
	return _c
}

func (_c *MockmeilisearchServiceReader_Index_Call) RunAndReturn(run func(uid string) meilisearch.IndexManager) *MockmeilisearchServiceReader_Index_Call {
	_c.Call.Return(run)
	return _c
}

// IsHealthy provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) IsHealthy() bool {
	ret := _mock.Called()

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

	var r0 bool
	if returnFunc, ok := ret.Get(0).(func() bool); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(bool)
	}
	return r0
}

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

// IsHealthy is a helper method to define mock.On call
func (_e *MockmeilisearchServiceReader_Expecter) IsHealthy() *MockmeilisearchServiceReader_IsHealthy_Call {
	return &MockmeilisearchServiceReader_IsHealthy_Call{Call: _e.mock.On("IsHealthy")}
}

func (_c *MockmeilisearchServiceReader_IsHealthy_Call) Run(run func()) *MockmeilisearchServiceReader_IsHealthy_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_IsHealthy_Call) Return(b bool) *MockmeilisearchServiceReader_IsHealthy_Call {
	_c.Call.Return(b)
	return _c
}

func (_c *MockmeilisearchServiceReader_IsHealthy_Call) RunAndReturn(run func() bool) *MockmeilisearchServiceReader_IsHealthy_Call {
	_c.Call.Return(run)
	return _c
}

// ListIndexes provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) ListIndexes(param *meilisearch.IndexesQuery) (*meilisearch.IndexesResults, error) {
	ret := _mock.Called(param)

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

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

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

// ListIndexes is a helper method to define mock.On call
//   - param *meilisearch.IndexesQuery
func (_e *MockmeilisearchServiceReader_Expecter) ListIndexes(param interface{}) *MockmeilisearchServiceReader_ListIndexes_Call {
	return &MockmeilisearchServiceReader_ListIndexes_Call{Call: _e.mock.On("ListIndexes", param)}
}

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

func (_c *MockmeilisearchServiceReader_ListIndexes_Call) Return(indexesResults *meilisearch.IndexesResults, err error) *MockmeilisearchServiceReader_ListIndexes_Call {
	_c.Call.Return(indexesResults, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_ListIndexes_Call) RunAndReturn(run func(param *meilisearch.IndexesQuery) (*meilisearch.IndexesResults, error)) *MockmeilisearchServiceReader_ListIndexes_Call {
	_c.Call.Return(run)
	return _c
}

// ListIndexesWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) ListIndexesWithContext(ctx context.Context, param *meilisearch.IndexesQuery) (*meilisearch.IndexesResults, error) {
	ret := _mock.Called(ctx, param)

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

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

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

// ListIndexesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - param *meilisearch.IndexesQuery
func (_e *MockmeilisearchServiceReader_Expecter) ListIndexesWithContext(ctx interface{}, param interface{}) *MockmeilisearchServiceReader_ListIndexesWithContext_Call {
	return &MockmeilisearchServiceReader_ListIndexesWithContext_Call{Call: _e.mock.On("ListIndexesWithContext", ctx, param)}
}

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

func (_c *MockmeilisearchServiceReader_ListIndexesWithContext_Call) Return(indexesResults *meilisearch.IndexesResults, err error) *MockmeilisearchServiceReader_ListIndexesWithContext_Call {
	_c.Call.Return(indexesResults, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_ListIndexesWithContext_Call) RunAndReturn(run func(ctx context.Context, param *meilisearch.IndexesQuery) (*meilisearch.IndexesResults, error)) *MockmeilisearchServiceReader_ListIndexesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// MultiSearch provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) MultiSearch(queries *meilisearch.MultiSearchRequest) (*meilisearch.MultiSearchResponse, error) {
	ret := _mock.Called(queries)

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

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

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

// MultiSearch is a helper method to define mock.On call
//   - queries *meilisearch.MultiSearchRequest
func (_e *MockmeilisearchServiceReader_Expecter) MultiSearch(queries interface{}) *MockmeilisearchServiceReader_MultiSearch_Call {
	return &MockmeilisearchServiceReader_MultiSearch_Call{Call: _e.mock.On("MultiSearch", queries)}
}

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

func (_c *MockmeilisearchServiceReader_MultiSearch_Call) Return(multiSearchResponse *meilisearch.MultiSearchResponse, err error) *MockmeilisearchServiceReader_MultiSearch_Call {
	_c.Call.Return(multiSearchResponse, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_MultiSearch_Call) RunAndReturn(run func(queries *meilisearch.MultiSearchRequest) (*meilisearch.MultiSearchResponse, error)) *MockmeilisearchServiceReader_MultiSearch_Call {
	_c.Call.Return(run)
	return _c
}

// MultiSearchWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) MultiSearchWithContext(ctx context.Context, queries *meilisearch.MultiSearchRequest) (*meilisearch.MultiSearchResponse, error) {
	ret := _mock.Called(ctx, queries)

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

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

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

// MultiSearchWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - queries *meilisearch.MultiSearchRequest
func (_e *MockmeilisearchServiceReader_Expecter) MultiSearchWithContext(ctx interface{}, queries interface{}) *MockmeilisearchServiceReader_MultiSearchWithContext_Call {
	return &MockmeilisearchServiceReader_MultiSearchWithContext_Call{Call: _e.mock.On("MultiSearchWithContext", ctx, queries)}
}

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

func (_c *MockmeilisearchServiceReader_MultiSearchWithContext_Call) Return(multiSearchResponse *meilisearch.MultiSearchResponse, err error) *MockmeilisearchServiceReader_MultiSearchWithContext_Call {
	_c.Call.Return(multiSearchResponse, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_MultiSearchWithContext_Call) RunAndReturn(run func(ctx context.Context, queries *meilisearch.MultiSearchRequest) (*meilisearch.MultiSearchResponse, error)) *MockmeilisearchServiceReader_MultiSearchWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// Version provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) Version() (*meilisearch.Version, error) {
	ret := _mock.Called()

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

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

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

// Version is a helper method to define mock.On call
func (_e *MockmeilisearchServiceReader_Expecter) Version() *MockmeilisearchServiceReader_Version_Call {
	return &MockmeilisearchServiceReader_Version_Call{Call: _e.mock.On("Version")}
}

func (_c *MockmeilisearchServiceReader_Version_Call) Run(run func()) *MockmeilisearchServiceReader_Version_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockmeilisearchServiceReader_Version_Call) Return(version *meilisearch.Version, err error) *MockmeilisearchServiceReader_Version_Call {
	_c.Call.Return(version, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_Version_Call) RunAndReturn(run func() (*meilisearch.Version, error)) *MockmeilisearchServiceReader_Version_Call {
	_c.Call.Return(run)
	return _c
}

// VersionWithContext provides a mock function for the type MockmeilisearchServiceReader
func (_mock *MockmeilisearchServiceReader) VersionWithContext(ctx context.Context) (*meilisearch.Version, error) {
	ret := _mock.Called(ctx)

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

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

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

// VersionWithContext is a helper method to define mock.On call
//   - ctx context.Context
func (_e *MockmeilisearchServiceReader_Expecter) VersionWithContext(ctx interface{}) *MockmeilisearchServiceReader_VersionWithContext_Call {
	return &MockmeilisearchServiceReader_VersionWithContext_Call{Call: _e.mock.On("VersionWithContext", ctx)}
}

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

func (_c *MockmeilisearchServiceReader_VersionWithContext_Call) Return(version *meilisearch.Version, err error) *MockmeilisearchServiceReader_VersionWithContext_Call {
	_c.Call.Return(version, err)
	return _c
}

func (_c *MockmeilisearchServiceReader_VersionWithContext_Call) RunAndReturn(run func(ctx context.Context) (*meilisearch.Version, error)) *MockmeilisearchServiceReader_VersionWithContext_Call {
	_c.Call.Return(run)
	return _c
}
