search-go/mocks/meilisearch_settings_manager_mock.go

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

package mocks

import (
	"context"

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

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

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

	return mock
}

// MockmeilisearchSettingsManager is an autogenerated mock type for the SettingsManager type
type MockmeilisearchSettingsManager struct {
	mock.Mock
}

type MockmeilisearchSettingsManager_Expecter struct {
	mock *mock.Mock
}

func (_m *MockmeilisearchSettingsManager) EXPECT() *MockmeilisearchSettingsManager_Expecter {
	return &MockmeilisearchSettingsManager_Expecter{mock: &_m.Mock}
}

// GetDictionary provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetDictionaryWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetDisplayedAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetDisplayedAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetDistinctAttribute provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetDistinctAttributeWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetEmbedders provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetEmbeddersWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetFacetSearch provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetFacetSearchWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetFaceting provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetFacetingWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetFilterableAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetFilterableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetLocalizedAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetLocalizedAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetNonSeparatorTokens provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetNonSeparatorTokensWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetPagination provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetPaginationWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetPrefixSearch provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetPrefixSearchWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetProximityPrecision provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetProximityPrecisionWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetRankingRules provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetRankingRulesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetSearchCutoffMs provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetSearchCutoffMsWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetSearchableAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetSearchableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetSeparatorTokens provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetSeparatorTokensWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetSettings provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetSettingsWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetSortableAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetSortableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetStopWords provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetStopWordsWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetSynonyms provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetSynonymsWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

// GetTypoTolerance provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

// GetTypoToleranceWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) 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
}

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

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

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

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

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

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

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

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

// ResetDictionary is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetDictionary() *MockmeilisearchSettingsManager_ResetDictionary_Call {
	return &MockmeilisearchSettingsManager_ResetDictionary_Call{Call: _e.mock.On("ResetDictionary")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetDictionaryWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetDictionaryWithContext_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 *MockmeilisearchSettingsManager_ResetDictionaryWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetDictionaryWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetDisplayedAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetDisplayedAttributes() *MockmeilisearchSettingsManager_ResetDisplayedAttributes_Call {
	return &MockmeilisearchSettingsManager_ResetDisplayedAttributes_Call{Call: _e.mock.On("ResetDisplayedAttributes")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetDisplayedAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetDisplayedAttributesWithContext_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 *MockmeilisearchSettingsManager_ResetDisplayedAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetDisplayedAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetDistinctAttribute is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetDistinctAttribute() *MockmeilisearchSettingsManager_ResetDistinctAttribute_Call {
	return &MockmeilisearchSettingsManager_ResetDistinctAttribute_Call{Call: _e.mock.On("ResetDistinctAttribute")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetDistinctAttributeWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetDistinctAttributeWithContext_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 *MockmeilisearchSettingsManager_ResetDistinctAttributeWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetDistinctAttributeWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetEmbedders is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetEmbedders() *MockmeilisearchSettingsManager_ResetEmbedders_Call {
	return &MockmeilisearchSettingsManager_ResetEmbedders_Call{Call: _e.mock.On("ResetEmbedders")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetEmbeddersWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetEmbeddersWithContext_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 *MockmeilisearchSettingsManager_ResetEmbeddersWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetEmbeddersWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetFacetSearch is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetFacetSearch() *MockmeilisearchSettingsManager_ResetFacetSearch_Call {
	return &MockmeilisearchSettingsManager_ResetFacetSearch_Call{Call: _e.mock.On("ResetFacetSearch")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetFacetSearchWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetFacetSearchWithContext_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 *MockmeilisearchSettingsManager_ResetFacetSearchWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetFacetSearchWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetFaceting is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetFaceting() *MockmeilisearchSettingsManager_ResetFaceting_Call {
	return &MockmeilisearchSettingsManager_ResetFaceting_Call{Call: _e.mock.On("ResetFaceting")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetFacetingWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetFacetingWithContext_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 *MockmeilisearchSettingsManager_ResetFacetingWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetFacetingWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetFilterableAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetFilterableAttributes() *MockmeilisearchSettingsManager_ResetFilterableAttributes_Call {
	return &MockmeilisearchSettingsManager_ResetFilterableAttributes_Call{Call: _e.mock.On("ResetFilterableAttributes")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetFilterableAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetFilterableAttributesWithContext_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 *MockmeilisearchSettingsManager_ResetFilterableAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetFilterableAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetLocalizedAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetLocalizedAttributes() *MockmeilisearchSettingsManager_ResetLocalizedAttributes_Call {
	return &MockmeilisearchSettingsManager_ResetLocalizedAttributes_Call{Call: _e.mock.On("ResetLocalizedAttributes")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetLocalizedAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetLocalizedAttributesWithContext_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 *MockmeilisearchSettingsManager_ResetLocalizedAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetLocalizedAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetNonSeparatorTokens is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetNonSeparatorTokens() *MockmeilisearchSettingsManager_ResetNonSeparatorTokens_Call {
	return &MockmeilisearchSettingsManager_ResetNonSeparatorTokens_Call{Call: _e.mock.On("ResetNonSeparatorTokens")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetNonSeparatorTokensWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetNonSeparatorTokensWithContext_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 *MockmeilisearchSettingsManager_ResetNonSeparatorTokensWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetNonSeparatorTokensWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetPagination is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetPagination() *MockmeilisearchSettingsManager_ResetPagination_Call {
	return &MockmeilisearchSettingsManager_ResetPagination_Call{Call: _e.mock.On("ResetPagination")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetPaginationWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetPaginationWithContext_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 *MockmeilisearchSettingsManager_ResetPaginationWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetPaginationWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetPrefixSearch is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetPrefixSearch() *MockmeilisearchSettingsManager_ResetPrefixSearch_Call {
	return &MockmeilisearchSettingsManager_ResetPrefixSearch_Call{Call: _e.mock.On("ResetPrefixSearch")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetPrefixSearchWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetPrefixSearchWithContext_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 *MockmeilisearchSettingsManager_ResetPrefixSearchWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetPrefixSearchWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetProximityPrecision is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetProximityPrecision() *MockmeilisearchSettingsManager_ResetProximityPrecision_Call {
	return &MockmeilisearchSettingsManager_ResetProximityPrecision_Call{Call: _e.mock.On("ResetProximityPrecision")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetProximityPrecisionWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetProximityPrecisionWithContext_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 *MockmeilisearchSettingsManager_ResetProximityPrecisionWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetProximityPrecisionWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetRankingRules is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetRankingRules() *MockmeilisearchSettingsManager_ResetRankingRules_Call {
	return &MockmeilisearchSettingsManager_ResetRankingRules_Call{Call: _e.mock.On("ResetRankingRules")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetRankingRulesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetRankingRulesWithContext_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 *MockmeilisearchSettingsManager_ResetRankingRulesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetRankingRulesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetSearchCutoffMs is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetSearchCutoffMs() *MockmeilisearchSettingsManager_ResetSearchCutoffMs_Call {
	return &MockmeilisearchSettingsManager_ResetSearchCutoffMs_Call{Call: _e.mock.On("ResetSearchCutoffMs")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetSearchCutoffMsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetSearchCutoffMsWithContext_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 *MockmeilisearchSettingsManager_ResetSearchCutoffMsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetSearchCutoffMsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetSearchableAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetSearchableAttributes() *MockmeilisearchSettingsManager_ResetSearchableAttributes_Call {
	return &MockmeilisearchSettingsManager_ResetSearchableAttributes_Call{Call: _e.mock.On("ResetSearchableAttributes")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetSearchableAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetSearchableAttributesWithContext_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 *MockmeilisearchSettingsManager_ResetSearchableAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetSearchableAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetSeparatorTokens is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetSeparatorTokens() *MockmeilisearchSettingsManager_ResetSeparatorTokens_Call {
	return &MockmeilisearchSettingsManager_ResetSeparatorTokens_Call{Call: _e.mock.On("ResetSeparatorTokens")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetSeparatorTokensWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetSeparatorTokensWithContext_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 *MockmeilisearchSettingsManager_ResetSeparatorTokensWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetSeparatorTokensWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetSettings is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetSettings() *MockmeilisearchSettingsManager_ResetSettings_Call {
	return &MockmeilisearchSettingsManager_ResetSettings_Call{Call: _e.mock.On("ResetSettings")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetSettingsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetSettingsWithContext_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 *MockmeilisearchSettingsManager_ResetSettingsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetSettingsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetSortableAttributes is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetSortableAttributes() *MockmeilisearchSettingsManager_ResetSortableAttributes_Call {
	return &MockmeilisearchSettingsManager_ResetSortableAttributes_Call{Call: _e.mock.On("ResetSortableAttributes")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetSortableAttributesWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetSortableAttributesWithContext_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 *MockmeilisearchSettingsManager_ResetSortableAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetSortableAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetStopWords is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetStopWords() *MockmeilisearchSettingsManager_ResetStopWords_Call {
	return &MockmeilisearchSettingsManager_ResetStopWords_Call{Call: _e.mock.On("ResetStopWords")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetStopWordsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetStopWordsWithContext_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 *MockmeilisearchSettingsManager_ResetStopWordsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetStopWordsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetSynonyms is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetSynonyms() *MockmeilisearchSettingsManager_ResetSynonyms_Call {
	return &MockmeilisearchSettingsManager_ResetSynonyms_Call{Call: _e.mock.On("ResetSynonyms")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetSynonymsWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetSynonymsWithContext_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 *MockmeilisearchSettingsManager_ResetSynonymsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetSynonymsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

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

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

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

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

// ResetTypoTolerance is a helper method to define mock.On call
func (_e *MockmeilisearchSettingsManager_Expecter) ResetTypoTolerance() *MockmeilisearchSettingsManager_ResetTypoTolerance_Call {
	return &MockmeilisearchSettingsManager_ResetTypoTolerance_Call{Call: _e.mock.On("ResetTypoTolerance")}
}

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

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

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

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

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

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

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

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

func (_c *MockmeilisearchSettingsManager_ResetTypoToleranceWithContext_Call) Run(run func(ctx context.Context)) *MockmeilisearchSettingsManager_ResetTypoToleranceWithContext_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 *MockmeilisearchSettingsManager_ResetTypoToleranceWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_ResetTypoToleranceWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateDictionary provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateDictionary(words []string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(words)

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

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

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

// UpdateDictionary is a helper method to define mock.On call
//   - words []string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateDictionary(words interface{}) *MockmeilisearchSettingsManager_UpdateDictionary_Call {
	return &MockmeilisearchSettingsManager_UpdateDictionary_Call{Call: _e.mock.On("UpdateDictionary", words)}
}

func (_c *MockmeilisearchSettingsManager_UpdateDictionary_Call) Run(run func(words []string)) *MockmeilisearchSettingsManager_UpdateDictionary_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 *MockmeilisearchSettingsManager_UpdateDictionary_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateDictionary_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateDictionary_Call) RunAndReturn(run func(words []string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateDictionary_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDictionaryWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateDictionaryWithContext(ctx context.Context, words []string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, words)

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

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

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

// UpdateDictionaryWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - words []string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateDictionaryWithContext(ctx interface{}, words interface{}) *MockmeilisearchSettingsManager_UpdateDictionaryWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateDictionaryWithContext_Call{Call: _e.mock.On("UpdateDictionaryWithContext", ctx, words)}
}

func (_c *MockmeilisearchSettingsManager_UpdateDictionaryWithContext_Call) Run(run func(ctx context.Context, words []string)) *MockmeilisearchSettingsManager_UpdateDictionaryWithContext_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 *MockmeilisearchSettingsManager_UpdateDictionaryWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateDictionaryWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateDisplayedAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateDisplayedAttributes(request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateDisplayedAttributes is a helper method to define mock.On call
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateDisplayedAttributes(request interface{}) *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call {
	return &MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call{Call: _e.mock.On("UpdateDisplayedAttributes", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call) Run(run func(request *[]string)) *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_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 *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call) RunAndReturn(run func(request *[]string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateDisplayedAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDisplayedAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateDisplayedAttributesWithContext(ctx context.Context, request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateDisplayedAttributesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateDisplayedAttributesWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateDisplayedAttributesWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateDisplayedAttributesWithContext_Call{Call: _e.mock.On("UpdateDisplayedAttributesWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateDisplayedAttributesWithContext_Call) Run(run func(ctx context.Context, request *[]string)) *MockmeilisearchSettingsManager_UpdateDisplayedAttributesWithContext_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 *MockmeilisearchSettingsManager_UpdateDisplayedAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateDisplayedAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateDistinctAttribute provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateDistinctAttribute(request string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateDistinctAttribute is a helper method to define mock.On call
//   - request string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateDistinctAttribute(request interface{}) *MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call {
	return &MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call{Call: _e.mock.On("UpdateDistinctAttribute", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call) Run(run func(request string)) *MockmeilisearchSettingsManager_UpdateDistinctAttribute_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 *MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call) RunAndReturn(run func(request string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateDistinctAttribute_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateDistinctAttributeWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateDistinctAttributeWithContext(ctx context.Context, request string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateDistinctAttributeWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateDistinctAttributeWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call{Call: _e.mock.On("UpdateDistinctAttributeWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call) Run(run func(ctx context.Context, request string)) *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_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 *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call) RunAndReturn(run func(ctx context.Context, request string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateDistinctAttributeWithContext_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// UpdateEmbedders is a helper method to define mock.On call
//   - request map[string]meilisearch.Embedder
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateEmbedders(request interface{}) *MockmeilisearchSettingsManager_UpdateEmbedders_Call {
	return &MockmeilisearchSettingsManager_UpdateEmbedders_Call{Call: _e.mock.On("UpdateEmbedders", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateEmbedders_Call) Run(run func(request map[string]meilisearch.Embedder)) *MockmeilisearchSettingsManager_UpdateEmbedders_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 map[string]meilisearch.Embedder
		if args[0] != nil {
			arg0 = args[0].(map[string]meilisearch.Embedder)
		}
		run(
			arg0,
		)
	})
	return _c
}

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

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

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

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

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

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

// UpdateEmbeddersWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request map[string]meilisearch.Embedder
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateEmbeddersWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateEmbeddersWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateEmbeddersWithContext_Call{Call: _e.mock.On("UpdateEmbeddersWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateEmbeddersWithContext_Call) Run(run func(ctx context.Context, request map[string]meilisearch.Embedder)) *MockmeilisearchSettingsManager_UpdateEmbeddersWithContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 map[string]meilisearch.Embedder
		if args[1] != nil {
			arg1 = args[1].(map[string]meilisearch.Embedder)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

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

// UpdateFacetSearch provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateFacetSearch(request bool) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateFacetSearch is a helper method to define mock.On call
//   - request bool
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateFacetSearch(request interface{}) *MockmeilisearchSettingsManager_UpdateFacetSearch_Call {
	return &MockmeilisearchSettingsManager_UpdateFacetSearch_Call{Call: _e.mock.On("UpdateFacetSearch", request)}
}

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

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

func (_c *MockmeilisearchSettingsManager_UpdateFacetSearch_Call) RunAndReturn(run func(request bool) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateFacetSearch_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFacetSearchWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateFacetSearchWithContext(ctx context.Context, request bool) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateFacetSearchWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request bool
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateFacetSearchWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateFacetSearchWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateFacetSearchWithContext_Call{Call: _e.mock.On("UpdateFacetSearchWithContext", ctx, request)}
}

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

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

func (_c *MockmeilisearchSettingsManager_UpdateFacetSearchWithContext_Call) RunAndReturn(run func(ctx context.Context, request bool) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateFacetSearchWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateFaceting provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateFaceting(request *meilisearch.Faceting) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateFaceting is a helper method to define mock.On call
//   - request *meilisearch.Faceting
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateFaceting(request interface{}) *MockmeilisearchSettingsManager_UpdateFaceting_Call {
	return &MockmeilisearchSettingsManager_UpdateFaceting_Call{Call: _e.mock.On("UpdateFaceting", request)}
}

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

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

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

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

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

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

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

// UpdateFacetingWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *meilisearch.Faceting
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateFacetingWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateFacetingWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateFacetingWithContext_Call{Call: _e.mock.On("UpdateFacetingWithContext", ctx, request)}
}

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

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

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

// UpdateFilterableAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateFilterableAttributes(request *[]interface{}) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateFilterableAttributes is a helper method to define mock.On call
//   - request *[]interface{}
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateFilterableAttributes(request interface{}) *MockmeilisearchSettingsManager_UpdateFilterableAttributes_Call {
	return &MockmeilisearchSettingsManager_UpdateFilterableAttributes_Call{Call: _e.mock.On("UpdateFilterableAttributes", request)}
}

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

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

func (_c *MockmeilisearchSettingsManager_UpdateFilterableAttributes_Call) RunAndReturn(run func(request *[]interface{}) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateFilterableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

// UpdateFilterableAttributesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *[]interface{}
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateFilterableAttributesWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateFilterableAttributesWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateFilterableAttributesWithContext_Call{Call: _e.mock.On("UpdateFilterableAttributesWithContext", ctx, request)}
}

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

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

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

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

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

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

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

// UpdateLocalizedAttributes is a helper method to define mock.On call
//   - request []*meilisearch.LocalizedAttributes
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateLocalizedAttributes(request interface{}) *MockmeilisearchSettingsManager_UpdateLocalizedAttributes_Call {
	return &MockmeilisearchSettingsManager_UpdateLocalizedAttributes_Call{Call: _e.mock.On("UpdateLocalizedAttributes", request)}
}

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

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

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

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

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

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

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

// UpdateLocalizedAttributesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request []*meilisearch.LocalizedAttributes
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateLocalizedAttributesWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateLocalizedAttributesWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateLocalizedAttributesWithContext_Call{Call: _e.mock.On("UpdateLocalizedAttributesWithContext", ctx, request)}
}

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

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

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

// UpdateNonSeparatorTokens provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateNonSeparatorTokens(tokens []string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(tokens)

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

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

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

// UpdateNonSeparatorTokens is a helper method to define mock.On call
//   - tokens []string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateNonSeparatorTokens(tokens interface{}) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call {
	return &MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call{Call: _e.mock.On("UpdateNonSeparatorTokens", tokens)}
}

func (_c *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call) Run(run func(tokens []string)) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_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 *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call) RunAndReturn(run func(tokens []string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokens_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateNonSeparatorTokensWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateNonSeparatorTokensWithContext(ctx context.Context, tokens []string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, tokens)

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

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

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

// UpdateNonSeparatorTokensWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - tokens []string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateNonSeparatorTokensWithContext(ctx interface{}, tokens interface{}) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokensWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateNonSeparatorTokensWithContext_Call{Call: _e.mock.On("UpdateNonSeparatorTokensWithContext", ctx, tokens)}
}

func (_c *MockmeilisearchSettingsManager_UpdateNonSeparatorTokensWithContext_Call) Run(run func(ctx context.Context, tokens []string)) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokensWithContext_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 *MockmeilisearchSettingsManager_UpdateNonSeparatorTokensWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateNonSeparatorTokensWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdatePagination provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdatePagination(request *meilisearch.Pagination) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdatePagination is a helper method to define mock.On call
//   - request *meilisearch.Pagination
func (_e *MockmeilisearchSettingsManager_Expecter) UpdatePagination(request interface{}) *MockmeilisearchSettingsManager_UpdatePagination_Call {
	return &MockmeilisearchSettingsManager_UpdatePagination_Call{Call: _e.mock.On("UpdatePagination", request)}
}

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

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

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

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

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

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

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

// UpdatePaginationWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *meilisearch.Pagination
func (_e *MockmeilisearchSettingsManager_Expecter) UpdatePaginationWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdatePaginationWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdatePaginationWithContext_Call{Call: _e.mock.On("UpdatePaginationWithContext", ctx, request)}
}

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

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

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

// UpdatePrefixSearch provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdatePrefixSearch(request string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdatePrefixSearch is a helper method to define mock.On call
//   - request string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdatePrefixSearch(request interface{}) *MockmeilisearchSettingsManager_UpdatePrefixSearch_Call {
	return &MockmeilisearchSettingsManager_UpdatePrefixSearch_Call{Call: _e.mock.On("UpdatePrefixSearch", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdatePrefixSearch_Call) Run(run func(request string)) *MockmeilisearchSettingsManager_UpdatePrefixSearch_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 *MockmeilisearchSettingsManager_UpdatePrefixSearch_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdatePrefixSearch_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdatePrefixSearch_Call) RunAndReturn(run func(request string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdatePrefixSearch_Call {
	_c.Call.Return(run)
	return _c
}

// UpdatePrefixSearchWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdatePrefixSearchWithContext(ctx context.Context, request string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdatePrefixSearchWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdatePrefixSearchWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call{Call: _e.mock.On("UpdatePrefixSearchWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call) Run(run func(ctx context.Context, request string)) *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_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 *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call) RunAndReturn(run func(ctx context.Context, request string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdatePrefixSearchWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateProximityPrecision provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateProximityPrecision(proximityType meilisearch.ProximityPrecisionType) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(proximityType)

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

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

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

// UpdateProximityPrecision is a helper method to define mock.On call
//   - proximityType meilisearch.ProximityPrecisionType
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateProximityPrecision(proximityType interface{}) *MockmeilisearchSettingsManager_UpdateProximityPrecision_Call {
	return &MockmeilisearchSettingsManager_UpdateProximityPrecision_Call{Call: _e.mock.On("UpdateProximityPrecision", proximityType)}
}

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

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

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

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

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

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

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

// UpdateProximityPrecisionWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - proximityType meilisearch.ProximityPrecisionType
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateProximityPrecisionWithContext(ctx interface{}, proximityType interface{}) *MockmeilisearchSettingsManager_UpdateProximityPrecisionWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateProximityPrecisionWithContext_Call{Call: _e.mock.On("UpdateProximityPrecisionWithContext", ctx, proximityType)}
}

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

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

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

// UpdateRankingRules provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateRankingRules(request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateRankingRules is a helper method to define mock.On call
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateRankingRules(request interface{}) *MockmeilisearchSettingsManager_UpdateRankingRules_Call {
	return &MockmeilisearchSettingsManager_UpdateRankingRules_Call{Call: _e.mock.On("UpdateRankingRules", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateRankingRules_Call) Run(run func(request *[]string)) *MockmeilisearchSettingsManager_UpdateRankingRules_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 *MockmeilisearchSettingsManager_UpdateRankingRules_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateRankingRules_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateRankingRules_Call) RunAndReturn(run func(request *[]string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateRankingRules_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateRankingRulesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateRankingRulesWithContext(ctx context.Context, request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateRankingRulesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateRankingRulesWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateRankingRulesWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateRankingRulesWithContext_Call{Call: _e.mock.On("UpdateRankingRulesWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateRankingRulesWithContext_Call) Run(run func(ctx context.Context, request *[]string)) *MockmeilisearchSettingsManager_UpdateRankingRulesWithContext_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 *MockmeilisearchSettingsManager_UpdateRankingRulesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateRankingRulesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateSearchCutoffMs provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSearchCutoffMs(request int64) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateSearchCutoffMs is a helper method to define mock.On call
//   - request int64
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSearchCutoffMs(request interface{}) *MockmeilisearchSettingsManager_UpdateSearchCutoffMs_Call {
	return &MockmeilisearchSettingsManager_UpdateSearchCutoffMs_Call{Call: _e.mock.On("UpdateSearchCutoffMs", request)}
}

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

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

func (_c *MockmeilisearchSettingsManager_UpdateSearchCutoffMs_Call) RunAndReturn(run func(request int64) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateSearchCutoffMs_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSearchCutoffMsWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSearchCutoffMsWithContext(ctx context.Context, request int64) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateSearchCutoffMsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request int64
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSearchCutoffMsWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateSearchCutoffMsWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateSearchCutoffMsWithContext_Call{Call: _e.mock.On("UpdateSearchCutoffMsWithContext", ctx, request)}
}

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

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

func (_c *MockmeilisearchSettingsManager_UpdateSearchCutoffMsWithContext_Call) RunAndReturn(run func(ctx context.Context, request int64) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateSearchCutoffMsWithContext_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSearchableAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSearchableAttributes(request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateSearchableAttributes is a helper method to define mock.On call
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSearchableAttributes(request interface{}) *MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call {
	return &MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call{Call: _e.mock.On("UpdateSearchableAttributes", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call) Run(run func(request *[]string)) *MockmeilisearchSettingsManager_UpdateSearchableAttributes_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 *MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call) RunAndReturn(run func(request *[]string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateSearchableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSearchableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSearchableAttributesWithContext(ctx context.Context, request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateSearchableAttributesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSearchableAttributesWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateSearchableAttributesWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateSearchableAttributesWithContext_Call{Call: _e.mock.On("UpdateSearchableAttributesWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateSearchableAttributesWithContext_Call) Run(run func(ctx context.Context, request *[]string)) *MockmeilisearchSettingsManager_UpdateSearchableAttributesWithContext_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 *MockmeilisearchSettingsManager_UpdateSearchableAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateSearchableAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateSeparatorTokens provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSeparatorTokens(tokens []string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(tokens)

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

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

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

// UpdateSeparatorTokens is a helper method to define mock.On call
//   - tokens []string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSeparatorTokens(tokens interface{}) *MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call {
	return &MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call{Call: _e.mock.On("UpdateSeparatorTokens", tokens)}
}

func (_c *MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call) Run(run func(tokens []string)) *MockmeilisearchSettingsManager_UpdateSeparatorTokens_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 *MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call) RunAndReturn(run func(tokens []string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateSeparatorTokens_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSeparatorTokensWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSeparatorTokensWithContext(ctx context.Context, tokens []string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, tokens)

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

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

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

// UpdateSeparatorTokensWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - tokens []string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSeparatorTokensWithContext(ctx interface{}, tokens interface{}) *MockmeilisearchSettingsManager_UpdateSeparatorTokensWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateSeparatorTokensWithContext_Call{Call: _e.mock.On("UpdateSeparatorTokensWithContext", ctx, tokens)}
}

func (_c *MockmeilisearchSettingsManager_UpdateSeparatorTokensWithContext_Call) Run(run func(ctx context.Context, tokens []string)) *MockmeilisearchSettingsManager_UpdateSeparatorTokensWithContext_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 *MockmeilisearchSettingsManager_UpdateSeparatorTokensWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateSeparatorTokensWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateSettings provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSettings(request *meilisearch.Settings) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateSettings is a helper method to define mock.On call
//   - request *meilisearch.Settings
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSettings(request interface{}) *MockmeilisearchSettingsManager_UpdateSettings_Call {
	return &MockmeilisearchSettingsManager_UpdateSettings_Call{Call: _e.mock.On("UpdateSettings", request)}
}

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

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

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

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

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

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

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

// UpdateSettingsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *meilisearch.Settings
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSettingsWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateSettingsWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateSettingsWithContext_Call{Call: _e.mock.On("UpdateSettingsWithContext", ctx, request)}
}

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

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

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

// UpdateSortableAttributes provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSortableAttributes(request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateSortableAttributes is a helper method to define mock.On call
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSortableAttributes(request interface{}) *MockmeilisearchSettingsManager_UpdateSortableAttributes_Call {
	return &MockmeilisearchSettingsManager_UpdateSortableAttributes_Call{Call: _e.mock.On("UpdateSortableAttributes", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateSortableAttributes_Call) Run(run func(request *[]string)) *MockmeilisearchSettingsManager_UpdateSortableAttributes_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 *MockmeilisearchSettingsManager_UpdateSortableAttributes_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateSortableAttributes_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateSortableAttributes_Call) RunAndReturn(run func(request *[]string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateSortableAttributes_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateSortableAttributesWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSortableAttributesWithContext(ctx context.Context, request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateSortableAttributesWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSortableAttributesWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateSortableAttributesWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateSortableAttributesWithContext_Call{Call: _e.mock.On("UpdateSortableAttributesWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateSortableAttributesWithContext_Call) Run(run func(ctx context.Context, request *[]string)) *MockmeilisearchSettingsManager_UpdateSortableAttributesWithContext_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 *MockmeilisearchSettingsManager_UpdateSortableAttributesWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateSortableAttributesWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateStopWords provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateStopWords(request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateStopWords is a helper method to define mock.On call
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateStopWords(request interface{}) *MockmeilisearchSettingsManager_UpdateStopWords_Call {
	return &MockmeilisearchSettingsManager_UpdateStopWords_Call{Call: _e.mock.On("UpdateStopWords", request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateStopWords_Call) Run(run func(request *[]string)) *MockmeilisearchSettingsManager_UpdateStopWords_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 *MockmeilisearchSettingsManager_UpdateStopWords_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateStopWords_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

func (_c *MockmeilisearchSettingsManager_UpdateStopWords_Call) RunAndReturn(run func(request *[]string) (*meilisearch.TaskInfo, error)) *MockmeilisearchSettingsManager_UpdateStopWords_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStopWordsWithContext provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateStopWordsWithContext(ctx context.Context, request *[]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(ctx, request)

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

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

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

// UpdateStopWordsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *[]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateStopWordsWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateStopWordsWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateStopWordsWithContext_Call{Call: _e.mock.On("UpdateStopWordsWithContext", ctx, request)}
}

func (_c *MockmeilisearchSettingsManager_UpdateStopWordsWithContext_Call) Run(run func(ctx context.Context, request *[]string)) *MockmeilisearchSettingsManager_UpdateStopWordsWithContext_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 *MockmeilisearchSettingsManager_UpdateStopWordsWithContext_Call) Return(taskInfo *meilisearch.TaskInfo, err error) *MockmeilisearchSettingsManager_UpdateStopWordsWithContext_Call {
	_c.Call.Return(taskInfo, err)
	return _c
}

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

// UpdateSynonyms provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateSynonyms(request *map[string][]string) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateSynonyms is a helper method to define mock.On call
//   - request *map[string][]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSynonyms(request interface{}) *MockmeilisearchSettingsManager_UpdateSynonyms_Call {
	return &MockmeilisearchSettingsManager_UpdateSynonyms_Call{Call: _e.mock.On("UpdateSynonyms", request)}
}

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

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

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

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

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

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

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

// UpdateSynonymsWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *map[string][]string
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateSynonymsWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateSynonymsWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateSynonymsWithContext_Call{Call: _e.mock.On("UpdateSynonymsWithContext", ctx, request)}
}

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

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

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

// UpdateTypoTolerance provides a mock function for the type MockmeilisearchSettingsManager
func (_mock *MockmeilisearchSettingsManager) UpdateTypoTolerance(request *meilisearch.TypoTolerance) (*meilisearch.TaskInfo, error) {
	ret := _mock.Called(request)

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

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

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

// UpdateTypoTolerance is a helper method to define mock.On call
//   - request *meilisearch.TypoTolerance
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateTypoTolerance(request interface{}) *MockmeilisearchSettingsManager_UpdateTypoTolerance_Call {
	return &MockmeilisearchSettingsManager_UpdateTypoTolerance_Call{Call: _e.mock.On("UpdateTypoTolerance", request)}
}

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

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

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

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

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

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

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

// UpdateTypoToleranceWithContext is a helper method to define mock.On call
//   - ctx context.Context
//   - request *meilisearch.TypoTolerance
func (_e *MockmeilisearchSettingsManager_Expecter) UpdateTypoToleranceWithContext(ctx interface{}, request interface{}) *MockmeilisearchSettingsManager_UpdateTypoToleranceWithContext_Call {
	return &MockmeilisearchSettingsManager_UpdateTypoToleranceWithContext_Call{Call: _e.mock.On("UpdateTypoToleranceWithContext", ctx, request)}
}

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

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

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