// 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"
)

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

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

	return mock
}

// MockmeilisearchSettingsReader is an autogenerated mock type for the SettingsReader type
type MockmeilisearchSettingsReader struct {
	mock.Mock
}

type MockmeilisearchSettingsReader_Expecter struct {
	mock *mock.Mock
}

func (_m *MockmeilisearchSettingsReader) EXPECT() *MockmeilisearchSettingsReader_Expecter {
	return &MockmeilisearchSettingsReader_Expecter{mock: &_m.Mock}
}

// GetDictionary provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetDictionary() ([]string, error) {
	ret := _mock.Called()

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

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

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

// GetDictionary is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetDictionary() *MockmeilisearchSettingsReader_GetDictionary_Call {
	return &MockmeilisearchSettingsReader_GetDictionary_Call{Call: _e.mock.On("GetDictionary")}
}

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

func (_c *MockmeilisearchSettingsReader_GetDictionary_Call) Return(strings []string, err error) *MockmeilisearchSettingsReader_GetDictionary_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetDictionary_Call) RunAndReturn(run func() ([]string, error)) *MockmeilisearchSettingsReader_GetDictionary_Call {
	_c.Call.Return(run)
	return _c
}

// GetDictionaryWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetDictionaryWithContext(ctx context.Context) ([]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetDictionaryWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetDictionaryWithContext_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 *MockmeilisearchSettingsReader_GetDictionaryWithContext_Call) Return(strings []string, err error) *MockmeilisearchSettingsReader_GetDictionaryWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetDisplayedAttributes provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetDisplayedAttributes() (*[]string, error) {
	ret := _mock.Called()

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

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

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

// GetDisplayedAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetDisplayedAttributes() *MockmeilisearchSettingsReader_GetDisplayedAttributes_Call {
	return &MockmeilisearchSettingsReader_GetDisplayedAttributes_Call{Call: _e.mock.On("GetDisplayedAttributes")}
}

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

func (_c *MockmeilisearchSettingsReader_GetDisplayedAttributes_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetDisplayedAttributes_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetDisplayedAttributes_Call) RunAndReturn(run func() (*[]string, error)) *MockmeilisearchSettingsReader_GetDisplayedAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetDisplayedAttributesWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetDisplayedAttributesWithContext(ctx context.Context) (*[]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetDisplayedAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetDisplayedAttributesWithContext_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 *MockmeilisearchSettingsReader_GetDisplayedAttributesWithContext_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetDisplayedAttributesWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetDistinctAttribute provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetDistinctAttribute() (*string, error) {
	ret := _mock.Called()

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

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

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

// GetDistinctAttribute is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetDistinctAttribute() *MockmeilisearchSettingsReader_GetDistinctAttribute_Call {
	return &MockmeilisearchSettingsReader_GetDistinctAttribute_Call{Call: _e.mock.On("GetDistinctAttribute")}
}

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

func (_c *MockmeilisearchSettingsReader_GetDistinctAttribute_Call) Return(s *string, err error) *MockmeilisearchSettingsReader_GetDistinctAttribute_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetDistinctAttribute_Call) RunAndReturn(run func() (*string, error)) *MockmeilisearchSettingsReader_GetDistinctAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// GetDistinctAttributeWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetDistinctAttributeWithContext(ctx context.Context) (*string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetDistinctAttributeWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetDistinctAttributeWithContext_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 *MockmeilisearchSettingsReader_GetDistinctAttributeWithContext_Call) Return(s *string, err error) *MockmeilisearchSettingsReader_GetDistinctAttributeWithContext_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetDistinctAttributeWithContext_Call) RunAndReturn(run func(ctx context.Context) (*string, error)) *MockmeilisearchSettingsReader_GetDistinctAttributeWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetEmbedders provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetEmbedders() (map[string]meilisearch.Embedder, error) {
	ret := _mock.Called()

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

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

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

// GetEmbedders is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetEmbedders() *MockmeilisearchSettingsReader_GetEmbedders_Call {
	return &MockmeilisearchSettingsReader_GetEmbedders_Call{Call: _e.mock.On("GetEmbedders")}
}

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

func (_c *MockmeilisearchSettingsReader_GetEmbedders_Call) Return(stringToEmbedder map[string]meilisearch.Embedder, err error) *MockmeilisearchSettingsReader_GetEmbedders_Call {
	_c.Call.Return(stringToEmbedder, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetEmbedders_Call) RunAndReturn(run func() (map[string]meilisearch.Embedder, error)) *MockmeilisearchSettingsReader_GetEmbedders_Call {
	_c.Call.Return(run)
	return _c
}

// GetEmbeddersWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetEmbeddersWithContext(ctx context.Context) (map[string]meilisearch.Embedder, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetEmbeddersWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetEmbeddersWithContext_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 *MockmeilisearchSettingsReader_GetEmbeddersWithContext_Call) Return(stringToEmbedder map[string]meilisearch.Embedder, err error) *MockmeilisearchSettingsReader_GetEmbeddersWithContext_Call {
	_c.Call.Return(stringToEmbedder, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetEmbeddersWithContext_Call) RunAndReturn(run func(ctx context.Context) (map[string]meilisearch.Embedder, error)) *MockmeilisearchSettingsReader_GetEmbeddersWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetFacetSearch provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetFacetSearch() (bool, error) {
	ret := _mock.Called()

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

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

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

// GetFacetSearch is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetFacetSearch() *MockmeilisearchSettingsReader_GetFacetSearch_Call {
	return &MockmeilisearchSettingsReader_GetFacetSearch_Call{Call: _e.mock.On("GetFacetSearch")}
}

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

func (_c *MockmeilisearchSettingsReader_GetFacetSearch_Call) Return(b bool, err error) *MockmeilisearchSettingsReader_GetFacetSearch_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetFacetSearch_Call) RunAndReturn(run func() (bool, error)) *MockmeilisearchSettingsReader_GetFacetSearch_Call {
	_c.Call.Return(run)
	return _c
}

// GetFacetSearchWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetFacetSearchWithContext(ctx context.Context) (bool, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetFacetSearchWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetFacetSearchWithContext_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 *MockmeilisearchSettingsReader_GetFacetSearchWithContext_Call) Return(b bool, err error) *MockmeilisearchSettingsReader_GetFacetSearchWithContext_Call {
	_c.Call.Return(b, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetFacetSearchWithContext_Call) RunAndReturn(run func(ctx context.Context) (bool, error)) *MockmeilisearchSettingsReader_GetFacetSearchWithContext_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// GetFaceting is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetFaceting() *MockmeilisearchSettingsReader_GetFaceting_Call {
	return &MockmeilisearchSettingsReader_GetFaceting_Call{Call: _e.mock.On("GetFaceting")}
}

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

func (_c *MockmeilisearchSettingsReader_GetFaceting_Call) Return(faceting *meilisearch.Faceting, err error) *MockmeilisearchSettingsReader_GetFaceting_Call {
	_c.Call.Return(faceting, err)
	return _c
}

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetFacetingWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetFacetingWithContext_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 *MockmeilisearchSettingsReader_GetFacetingWithContext_Call) Return(faceting *meilisearch.Faceting, err error) *MockmeilisearchSettingsReader_GetFacetingWithContext_Call {
	_c.Call.Return(faceting, err)
	return _c
}

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

// GetFilterableAttributes provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetFilterableAttributes() (*[]interface{}, error) {
	ret := _mock.Called()

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

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

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

// GetFilterableAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetFilterableAttributes() *MockmeilisearchSettingsReader_GetFilterableAttributes_Call {
	return &MockmeilisearchSettingsReader_GetFilterableAttributes_Call{Call: _e.mock.On("GetFilterableAttributes")}
}

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

func (_c *MockmeilisearchSettingsReader_GetFilterableAttributes_Call) Return(ifaceVals *[]interface{}, err error) *MockmeilisearchSettingsReader_GetFilterableAttributes_Call {
	_c.Call.Return(ifaceVals, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetFilterableAttributes_Call) RunAndReturn(run func() (*[]interface{}, error)) *MockmeilisearchSettingsReader_GetFilterableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetFilterableAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetFilterableAttributesWithContext_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 *MockmeilisearchSettingsReader_GetFilterableAttributesWithContext_Call) Return(ifaceVals *[]interface{}, err error) *MockmeilisearchSettingsReader_GetFilterableAttributesWithContext_Call {
	_c.Call.Return(ifaceVals, err)
	return _c
}

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

// GetLocalizedAttributes provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetLocalizedAttributes() ([]*meilisearch.LocalizedAttributes, error) {
	ret := _mock.Called()

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

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

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

// GetLocalizedAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetLocalizedAttributes() *MockmeilisearchSettingsReader_GetLocalizedAttributes_Call {
	return &MockmeilisearchSettingsReader_GetLocalizedAttributes_Call{Call: _e.mock.On("GetLocalizedAttributes")}
}

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

func (_c *MockmeilisearchSettingsReader_GetLocalizedAttributes_Call) Return(localizedAttributess []*meilisearch.LocalizedAttributes, err error) *MockmeilisearchSettingsReader_GetLocalizedAttributes_Call {
	_c.Call.Return(localizedAttributess, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetLocalizedAttributes_Call) RunAndReturn(run func() ([]*meilisearch.LocalizedAttributes, error)) *MockmeilisearchSettingsReader_GetLocalizedAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetLocalizedAttributesWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetLocalizedAttributesWithContext(ctx context.Context) ([]*meilisearch.LocalizedAttributes, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetLocalizedAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetLocalizedAttributesWithContext_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 *MockmeilisearchSettingsReader_GetLocalizedAttributesWithContext_Call) Return(localizedAttributess []*meilisearch.LocalizedAttributes, err error) *MockmeilisearchSettingsReader_GetLocalizedAttributesWithContext_Call {
	_c.Call.Return(localizedAttributess, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetLocalizedAttributesWithContext_Call) RunAndReturn(run func(ctx context.Context) ([]*meilisearch.LocalizedAttributes, error)) *MockmeilisearchSettingsReader_GetLocalizedAttributesWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetNonSeparatorTokens provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetNonSeparatorTokens() ([]string, error) {
	ret := _mock.Called()

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

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

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

// GetNonSeparatorTokens is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetNonSeparatorTokens() *MockmeilisearchSettingsReader_GetNonSeparatorTokens_Call {
	return &MockmeilisearchSettingsReader_GetNonSeparatorTokens_Call{Call: _e.mock.On("GetNonSeparatorTokens")}
}

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

func (_c *MockmeilisearchSettingsReader_GetNonSeparatorTokens_Call) Return(strings []string, err error) *MockmeilisearchSettingsReader_GetNonSeparatorTokens_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetNonSeparatorTokens_Call) RunAndReturn(run func() ([]string, error)) *MockmeilisearchSettingsReader_GetNonSeparatorTokens_Call {
	_c.Call.Return(run)
	return _c
}

// GetNonSeparatorTokensWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetNonSeparatorTokensWithContext(ctx context.Context) ([]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetNonSeparatorTokensWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetNonSeparatorTokensWithContext_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 *MockmeilisearchSettingsReader_GetNonSeparatorTokensWithContext_Call) Return(strings []string, err error) *MockmeilisearchSettingsReader_GetNonSeparatorTokensWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

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

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

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

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

// GetPagination is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetPagination() *MockmeilisearchSettingsReader_GetPagination_Call {
	return &MockmeilisearchSettingsReader_GetPagination_Call{Call: _e.mock.On("GetPagination")}
}

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

func (_c *MockmeilisearchSettingsReader_GetPagination_Call) Return(pagination *meilisearch.Pagination, err error) *MockmeilisearchSettingsReader_GetPagination_Call {
	_c.Call.Return(pagination, err)
	return _c
}

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetPaginationWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetPaginationWithContext_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 *MockmeilisearchSettingsReader_GetPaginationWithContext_Call) Return(pagination *meilisearch.Pagination, err error) *MockmeilisearchSettingsReader_GetPaginationWithContext_Call {
	_c.Call.Return(pagination, err)
	return _c
}

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

// GetPrefixSearch provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetPrefixSearch() (*string, error) {
	ret := _mock.Called()

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

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

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

// GetPrefixSearch is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetPrefixSearch() *MockmeilisearchSettingsReader_GetPrefixSearch_Call {
	return &MockmeilisearchSettingsReader_GetPrefixSearch_Call{Call: _e.mock.On("GetPrefixSearch")}
}

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

func (_c *MockmeilisearchSettingsReader_GetPrefixSearch_Call) Return(s *string, err error) *MockmeilisearchSettingsReader_GetPrefixSearch_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetPrefixSearch_Call) RunAndReturn(run func() (*string, error)) *MockmeilisearchSettingsReader_GetPrefixSearch_Call {
	_c.Call.Return(run)
	return _c
}

// GetPrefixSearchWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetPrefixSearchWithContext(ctx context.Context) (*string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetPrefixSearchWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetPrefixSearchWithContext_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 *MockmeilisearchSettingsReader_GetPrefixSearchWithContext_Call) Return(s *string, err error) *MockmeilisearchSettingsReader_GetPrefixSearchWithContext_Call {
	_c.Call.Return(s, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetPrefixSearchWithContext_Call) RunAndReturn(run func(ctx context.Context) (*string, error)) *MockmeilisearchSettingsReader_GetPrefixSearchWithContext_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// GetProximityPrecision is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetProximityPrecision() *MockmeilisearchSettingsReader_GetProximityPrecision_Call {
	return &MockmeilisearchSettingsReader_GetProximityPrecision_Call{Call: _e.mock.On("GetProximityPrecision")}
}

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

func (_c *MockmeilisearchSettingsReader_GetProximityPrecision_Call) Return(proximityPrecisionType meilisearch.ProximityPrecisionType, err error) *MockmeilisearchSettingsReader_GetProximityPrecision_Call {
	_c.Call.Return(proximityPrecisionType, err)
	return _c
}

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetProximityPrecisionWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetProximityPrecisionWithContext_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 *MockmeilisearchSettingsReader_GetProximityPrecisionWithContext_Call) Return(proximityPrecisionType meilisearch.ProximityPrecisionType, err error) *MockmeilisearchSettingsReader_GetProximityPrecisionWithContext_Call {
	_c.Call.Return(proximityPrecisionType, err)
	return _c
}

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

// GetRankingRules provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetRankingRules() (*[]string, error) {
	ret := _mock.Called()

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

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

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

// GetRankingRules is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetRankingRules() *MockmeilisearchSettingsReader_GetRankingRules_Call {
	return &MockmeilisearchSettingsReader_GetRankingRules_Call{Call: _e.mock.On("GetRankingRules")}
}

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

func (_c *MockmeilisearchSettingsReader_GetRankingRules_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetRankingRules_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetRankingRules_Call) RunAndReturn(run func() (*[]string, error)) *MockmeilisearchSettingsReader_GetRankingRules_Call {
	_c.Call.Return(run)
	return _c
}

// GetRankingRulesWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetRankingRulesWithContext(ctx context.Context) (*[]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetRankingRulesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetRankingRulesWithContext_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 *MockmeilisearchSettingsReader_GetRankingRulesWithContext_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetRankingRulesWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetSearchCutoffMs provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSearchCutoffMs() (int64, error) {
	ret := _mock.Called()

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

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

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

// GetSearchCutoffMs is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetSearchCutoffMs() *MockmeilisearchSettingsReader_GetSearchCutoffMs_Call {
	return &MockmeilisearchSettingsReader_GetSearchCutoffMs_Call{Call: _e.mock.On("GetSearchCutoffMs")}
}

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

func (_c *MockmeilisearchSettingsReader_GetSearchCutoffMs_Call) Return(n int64, err error) *MockmeilisearchSettingsReader_GetSearchCutoffMs_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetSearchCutoffMs_Call) RunAndReturn(run func() (int64, error)) *MockmeilisearchSettingsReader_GetSearchCutoffMs_Call {
	_c.Call.Return(run)
	return _c
}

// GetSearchCutoffMsWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSearchCutoffMsWithContext(ctx context.Context) (int64, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetSearchCutoffMsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetSearchCutoffMsWithContext_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 *MockmeilisearchSettingsReader_GetSearchCutoffMsWithContext_Call) Return(n int64, err error) *MockmeilisearchSettingsReader_GetSearchCutoffMsWithContext_Call {
	_c.Call.Return(n, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetSearchCutoffMsWithContext_Call) RunAndReturn(run func(ctx context.Context) (int64, error)) *MockmeilisearchSettingsReader_GetSearchCutoffMsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// GetSearchableAttributes provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSearchableAttributes() (*[]string, error) {
	ret := _mock.Called()

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

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

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

// GetSearchableAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetSearchableAttributes() *MockmeilisearchSettingsReader_GetSearchableAttributes_Call {
	return &MockmeilisearchSettingsReader_GetSearchableAttributes_Call{Call: _e.mock.On("GetSearchableAttributes")}
}

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

func (_c *MockmeilisearchSettingsReader_GetSearchableAttributes_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetSearchableAttributes_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetSearchableAttributes_Call) RunAndReturn(run func() (*[]string, error)) *MockmeilisearchSettingsReader_GetSearchableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetSearchableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSearchableAttributesWithContext(ctx context.Context) (*[]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetSearchableAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetSearchableAttributesWithContext_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 *MockmeilisearchSettingsReader_GetSearchableAttributesWithContext_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetSearchableAttributesWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetSeparatorTokens provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSeparatorTokens() ([]string, error) {
	ret := _mock.Called()

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

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

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

// GetSeparatorTokens is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetSeparatorTokens() *MockmeilisearchSettingsReader_GetSeparatorTokens_Call {
	return &MockmeilisearchSettingsReader_GetSeparatorTokens_Call{Call: _e.mock.On("GetSeparatorTokens")}
}

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

func (_c *MockmeilisearchSettingsReader_GetSeparatorTokens_Call) Return(strings []string, err error) *MockmeilisearchSettingsReader_GetSeparatorTokens_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetSeparatorTokens_Call) RunAndReturn(run func() ([]string, error)) *MockmeilisearchSettingsReader_GetSeparatorTokens_Call {
	_c.Call.Return(run)
	return _c
}

// GetSeparatorTokensWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSeparatorTokensWithContext(ctx context.Context) ([]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetSeparatorTokensWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetSeparatorTokensWithContext_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 *MockmeilisearchSettingsReader_GetSeparatorTokensWithContext_Call) Return(strings []string, err error) *MockmeilisearchSettingsReader_GetSeparatorTokensWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

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

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

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

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

// GetSettings is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetSettings() *MockmeilisearchSettingsReader_GetSettings_Call {
	return &MockmeilisearchSettingsReader_GetSettings_Call{Call: _e.mock.On("GetSettings")}
}

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

func (_c *MockmeilisearchSettingsReader_GetSettings_Call) Return(settings *meilisearch.Settings, err error) *MockmeilisearchSettingsReader_GetSettings_Call {
	_c.Call.Return(settings, err)
	return _c
}

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetSettingsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetSettingsWithContext_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 *MockmeilisearchSettingsReader_GetSettingsWithContext_Call) Return(settings *meilisearch.Settings, err error) *MockmeilisearchSettingsReader_GetSettingsWithContext_Call {
	_c.Call.Return(settings, err)
	return _c
}

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

// GetSortableAttributes provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSortableAttributes() (*[]string, error) {
	ret := _mock.Called()

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

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

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

// GetSortableAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetSortableAttributes() *MockmeilisearchSettingsReader_GetSortableAttributes_Call {
	return &MockmeilisearchSettingsReader_GetSortableAttributes_Call{Call: _e.mock.On("GetSortableAttributes")}
}

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

func (_c *MockmeilisearchSettingsReader_GetSortableAttributes_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetSortableAttributes_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetSortableAttributes_Call) RunAndReturn(run func() (*[]string, error)) *MockmeilisearchSettingsReader_GetSortableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// GetSortableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSortableAttributesWithContext(ctx context.Context) (*[]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetSortableAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetSortableAttributesWithContext_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 *MockmeilisearchSettingsReader_GetSortableAttributesWithContext_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetSortableAttributesWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetStopWords provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetStopWords() (*[]string, error) {
	ret := _mock.Called()

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

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

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

// GetStopWords is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetStopWords() *MockmeilisearchSettingsReader_GetStopWords_Call {
	return &MockmeilisearchSettingsReader_GetStopWords_Call{Call: _e.mock.On("GetStopWords")}
}

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

func (_c *MockmeilisearchSettingsReader_GetStopWords_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetStopWords_Call {
	_c.Call.Return(strings, err)
	return _c
}

func (_c *MockmeilisearchSettingsReader_GetStopWords_Call) RunAndReturn(run func() (*[]string, error)) *MockmeilisearchSettingsReader_GetStopWords_Call {
	_c.Call.Return(run)
	return _c
}

// GetStopWordsWithContext provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetStopWordsWithContext(ctx context.Context) (*[]string, error) {
	ret := _mock.Called(ctx)

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetStopWordsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetStopWordsWithContext_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 *MockmeilisearchSettingsReader_GetStopWordsWithContext_Call) Return(strings *[]string, err error) *MockmeilisearchSettingsReader_GetStopWordsWithContext_Call {
	_c.Call.Return(strings, err)
	return _c
}

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

// GetSynonyms provides a mock function for the type MockmeilisearchSettingsReader
func (_mock *MockmeilisearchSettingsReader) GetSynonyms() (*map[string][]string, error) {
	ret := _mock.Called()

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

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

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

// GetSynonyms is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetSynonyms() *MockmeilisearchSettingsReader_GetSynonyms_Call {
	return &MockmeilisearchSettingsReader_GetSynonyms_Call{Call: _e.mock.On("GetSynonyms")}
}

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

func (_c *MockmeilisearchSettingsReader_GetSynonyms_Call) Return(stringToStrings *map[string][]string, err error) *MockmeilisearchSettingsReader_GetSynonyms_Call {
	_c.Call.Return(stringToStrings, err)
	return _c
}

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetSynonymsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetSynonymsWithContext_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 *MockmeilisearchSettingsReader_GetSynonymsWithContext_Call) Return(stringToStrings *map[string][]string, err error) *MockmeilisearchSettingsReader_GetSynonymsWithContext_Call {
	_c.Call.Return(stringToStrings, err)
	return _c
}

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

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

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

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

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

// GetTypoTolerance is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsReader_Expecter) GetTypoTolerance() *MockmeilisearchSettingsReader_GetTypoTolerance_Call {
	return &MockmeilisearchSettingsReader_GetTypoTolerance_Call{Call: _e.mock.On("GetTypoTolerance")}
}

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

func (_c *MockmeilisearchSettingsReader_GetTypoTolerance_Call) Return(typoTolerance *meilisearch.TypoTolerance, err error) *MockmeilisearchSettingsReader_GetTypoTolerance_Call {
	_c.Call.Return(typoTolerance, err)
	return _c
}

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsReader_GetTypoToleranceWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsReader_GetTypoToleranceWithContext_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 *MockmeilisearchSettingsReader_GetTypoToleranceWithContext_Call) Return(typoTolerance *meilisearch.TypoTolerance, err error) *MockmeilisearchSettingsReader_GetTypoToleranceWithContext_Call {
	_c.Call.Return(typoTolerance, err)
	return _c
}

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