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

package tokenizertest

import (
	"context"
	"time"

	"github.com/SigNoz/signoz/pkg/tokenizer"
	"github.com/SigNoz/signoz/pkg/types/authtypes"
	"github.com/SigNoz/signoz/pkg/valuer"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// MockTokenizer is an autogenerated mock type for the Tokenizer type
type MockTokenizer struct {
	mock.Mock
}

type MockTokenizer_Expecter struct {
	mock *mock.Mock
}

func (_m *MockTokenizer) EXPECT() *MockTokenizer_Expecter {
	return &MockTokenizer_Expecter{mock: &_m.Mock}
}

// Collect provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) Collect(context1 context.Context, uUID valuer.UUID) (map[string]any, error) {
	ret := _mock.Called(context1, uUID)

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

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

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

// Collect is a helper method to define mock.On call
//   - context1 context.Context
//   - uUID valuer.UUID
func (_e *MockTokenizer_Expecter) Collect(context1 interface{}, uUID interface{}) *MockTokenizer_Collect_Call {
	return &MockTokenizer_Collect_Call{Call: _e.mock.On("Collect", context1, uUID)}
}

func (_c *MockTokenizer_Collect_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_Collect_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockTokenizer_Collect_Call) Return(stringToV map[string]any, err error) *MockTokenizer_Collect_Call {
	_c.Call.Return(stringToV, err)
	return _c
}

func (_c *MockTokenizer_Collect_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (map[string]any, error)) *MockTokenizer_Collect_Call {
	_c.Call.Return(run)
	return _c
}

// Config provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) Config() tokenizer.Config {
	ret := _mock.Called()

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

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

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

// Config is a helper method to define mock.On call
func (_e *MockTokenizer_Expecter) Config() *MockTokenizer_Config_Call {
	return &MockTokenizer_Config_Call{Call: _e.mock.On("Config")}
}

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

func (_c *MockTokenizer_Config_Call) Return(config tokenizer.Config) *MockTokenizer_Config_Call {
	_c.Call.Return(config)
	return _c
}

func (_c *MockTokenizer_Config_Call) RunAndReturn(run func() tokenizer.Config) *MockTokenizer_Config_Call {
	_c.Call.Return(run)
	return _c
}

// CreateToken provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) CreateToken(context1 context.Context, identity *authtypes.Identity, stringToString map[string]string) (*authtypes.Token, error) {
	ret := _mock.Called(context1, identity, stringToString)

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

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

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

// CreateToken is a helper method to define mock.On call
//   - context1 context.Context
//   - identity *authtypes.Identity
//   - stringToString map[string]string
func (_e *MockTokenizer_Expecter) CreateToken(context1 interface{}, identity interface{}, stringToString interface{}) *MockTokenizer_CreateToken_Call {
	return &MockTokenizer_CreateToken_Call{Call: _e.mock.On("CreateToken", context1, identity, stringToString)}
}

func (_c *MockTokenizer_CreateToken_Call) Run(run func(context1 context.Context, identity *authtypes.Identity, stringToString map[string]string)) *MockTokenizer_CreateToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *authtypes.Identity
		if args[1] != nil {
			arg1 = args[1].(*authtypes.Identity)
		}
		var arg2 map[string]string
		if args[2] != nil {
			arg2 = args[2].(map[string]string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockTokenizer_CreateToken_Call) Return(token *authtypes.Token, err error) *MockTokenizer_CreateToken_Call {
	_c.Call.Return(token, err)
	return _c
}

func (_c *MockTokenizer_CreateToken_Call) RunAndReturn(run func(context1 context.Context, identity *authtypes.Identity, stringToString map[string]string) (*authtypes.Token, error)) *MockTokenizer_CreateToken_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteIdentity provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) DeleteIdentity(context1 context.Context, uUID valuer.UUID) error {
	ret := _mock.Called(context1, uUID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) error); ok {
		r0 = returnFunc(context1, uUID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteIdentity is a helper method to define mock.On call
//   - context1 context.Context
//   - uUID valuer.UUID
func (_e *MockTokenizer_Expecter) DeleteIdentity(context1 interface{}, uUID interface{}) *MockTokenizer_DeleteIdentity_Call {
	return &MockTokenizer_DeleteIdentity_Call{Call: _e.mock.On("DeleteIdentity", context1, uUID)}
}

func (_c *MockTokenizer_DeleteIdentity_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_DeleteIdentity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockTokenizer_DeleteIdentity_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) error) *MockTokenizer_DeleteIdentity_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteToken provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) DeleteToken(context1 context.Context, s string) error {
	ret := _mock.Called(context1, s)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok {
		r0 = returnFunc(context1, s)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteToken is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
func (_e *MockTokenizer_Expecter) DeleteToken(context1 interface{}, s interface{}) *MockTokenizer_DeleteToken_Call {
	return &MockTokenizer_DeleteToken_Call{Call: _e.mock.On("DeleteToken", context1, s)}
}

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

func (_c *MockTokenizer_DeleteToken_Call) RunAndReturn(run func(context1 context.Context, s string) error) *MockTokenizer_DeleteToken_Call {
	_c.Call.Return(run)
	return _c
}

// DeleteTokensByUserID provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) DeleteTokensByUserID(context1 context.Context, uUID valuer.UUID) error {
	ret := _mock.Called(context1, uUID)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) error); ok {
		r0 = returnFunc(context1, uUID)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteTokensByUserID is a helper method to define mock.On call
//   - context1 context.Context
//   - uUID valuer.UUID
func (_e *MockTokenizer_Expecter) DeleteTokensByUserID(context1 interface{}, uUID interface{}) *MockTokenizer_DeleteTokensByUserID_Call {
	return &MockTokenizer_DeleteTokensByUserID_Call{Call: _e.mock.On("DeleteTokensByUserID", context1, uUID)}
}

func (_c *MockTokenizer_DeleteTokensByUserID_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_DeleteTokensByUserID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

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

func (_c *MockTokenizer_DeleteTokensByUserID_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) error) *MockTokenizer_DeleteTokensByUserID_Call {
	_c.Call.Return(run)
	return _c
}

// GetIdentity provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) GetIdentity(context1 context.Context, s string) (*authtypes.Identity, error) {
	ret := _mock.Called(context1, s)

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

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

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

// GetIdentity is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
func (_e *MockTokenizer_Expecter) GetIdentity(context1 interface{}, s interface{}) *MockTokenizer_GetIdentity_Call {
	return &MockTokenizer_GetIdentity_Call{Call: _e.mock.On("GetIdentity", context1, s)}
}

func (_c *MockTokenizer_GetIdentity_Call) Run(run func(context1 context.Context, s string)) *MockTokenizer_GetIdentity_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 *MockTokenizer_GetIdentity_Call) Return(identity *authtypes.Identity, err error) *MockTokenizer_GetIdentity_Call {
	_c.Call.Return(identity, err)
	return _c
}

func (_c *MockTokenizer_GetIdentity_Call) RunAndReturn(run func(context1 context.Context, s string) (*authtypes.Identity, error)) *MockTokenizer_GetIdentity_Call {
	_c.Call.Return(run)
	return _c
}

// ListMaxLastObservedAtByOrgID provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) ListMaxLastObservedAtByOrgID(context1 context.Context, uUID valuer.UUID) (map[valuer.UUID]time.Time, error) {
	ret := _mock.Called(context1, uUID)

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

	var r0 map[valuer.UUID]time.Time
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) (map[valuer.UUID]time.Time, error)); ok {
		return returnFunc(context1, uUID)
	}
	if returnFunc, ok := ret.Get(0).(func(context.Context, valuer.UUID) map[valuer.UUID]time.Time); ok {
		r0 = returnFunc(context1, uUID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[valuer.UUID]time.Time)
		}
	}
	if returnFunc, ok := ret.Get(1).(func(context.Context, valuer.UUID) error); ok {
		r1 = returnFunc(context1, uUID)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

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

// ListMaxLastObservedAtByOrgID is a helper method to define mock.On call
//   - context1 context.Context
//   - uUID valuer.UUID
func (_e *MockTokenizer_Expecter) ListMaxLastObservedAtByOrgID(context1 interface{}, uUID interface{}) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call {
	return &MockTokenizer_ListMaxLastObservedAtByOrgID_Call{Call: _e.mock.On("ListMaxLastObservedAtByOrgID", context1, uUID)}
}

func (_c *MockTokenizer_ListMaxLastObservedAtByOrgID_Call) Run(run func(context1 context.Context, uUID valuer.UUID)) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 valuer.UUID
		if args[1] != nil {
			arg1 = args[1].(valuer.UUID)
		}
		run(
			arg0,
			arg1,
		)
	})
	return _c
}

func (_c *MockTokenizer_ListMaxLastObservedAtByOrgID_Call) Return(uUIDToTime map[valuer.UUID]time.Time, err error) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call {
	_c.Call.Return(uUIDToTime, err)
	return _c
}

func (_c *MockTokenizer_ListMaxLastObservedAtByOrgID_Call) RunAndReturn(run func(context1 context.Context, uUID valuer.UUID) (map[valuer.UUID]time.Time, error)) *MockTokenizer_ListMaxLastObservedAtByOrgID_Call {
	_c.Call.Return(run)
	return _c
}

// RotateToken provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) RotateToken(context1 context.Context, s string, s1 string) (*authtypes.Token, error) {
	ret := _mock.Called(context1, s, s1)

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

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

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

// RotateToken is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - s1 string
func (_e *MockTokenizer_Expecter) RotateToken(context1 interface{}, s interface{}, s1 interface{}) *MockTokenizer_RotateToken_Call {
	return &MockTokenizer_RotateToken_Call{Call: _e.mock.On("RotateToken", context1, s, s1)}
}

func (_c *MockTokenizer_RotateToken_Call) Run(run func(context1 context.Context, s string, s1 string)) *MockTokenizer_RotateToken_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 string
		if args[2] != nil {
			arg2 = args[2].(string)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

func (_c *MockTokenizer_RotateToken_Call) Return(token *authtypes.Token, err error) *MockTokenizer_RotateToken_Call {
	_c.Call.Return(token, err)
	return _c
}

func (_c *MockTokenizer_RotateToken_Call) RunAndReturn(run func(context1 context.Context, s string, s1 string) (*authtypes.Token, error)) *MockTokenizer_RotateToken_Call {
	_c.Call.Return(run)
	return _c
}

// SetLastObservedAt provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) SetLastObservedAt(context1 context.Context, s string, time1 time.Time) error {
	ret := _mock.Called(context1, s, time1)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, string, time.Time) error); ok {
		r0 = returnFunc(context1, s, time1)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetLastObservedAt is a helper method to define mock.On call
//   - context1 context.Context
//   - s string
//   - time1 time.Time
func (_e *MockTokenizer_Expecter) SetLastObservedAt(context1 interface{}, s interface{}, time1 interface{}) *MockTokenizer_SetLastObservedAt_Call {
	return &MockTokenizer_SetLastObservedAt_Call{Call: _e.mock.On("SetLastObservedAt", context1, s, time1)}
}

func (_c *MockTokenizer_SetLastObservedAt_Call) Run(run func(context1 context.Context, s string, time1 time.Time)) *MockTokenizer_SetLastObservedAt_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 string
		if args[1] != nil {
			arg1 = args[1].(string)
		}
		var arg2 time.Time
		if args[2] != nil {
			arg2 = args[2].(time.Time)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *MockTokenizer_SetLastObservedAt_Call) RunAndReturn(run func(context1 context.Context, s string, time1 time.Time) error) *MockTokenizer_SetLastObservedAt_Call {
	_c.Call.Return(run)
	return _c
}

// Start provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) Start(context1 context.Context) error {
	ret := _mock.Called(context1)

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

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

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

// Start is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockTokenizer_Expecter) Start(context1 interface{}) *MockTokenizer_Start_Call {
	return &MockTokenizer_Start_Call{Call: _e.mock.On("Start", context1)}
}

func (_c *MockTokenizer_Start_Call) Run(run func(context1 context.Context)) *MockTokenizer_Start_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 *MockTokenizer_Start_Call) Return(err error) *MockTokenizer_Start_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockTokenizer_Start_Call) RunAndReturn(run func(context1 context.Context) error) *MockTokenizer_Start_Call {
	_c.Call.Return(run)
	return _c
}

// Stop provides a mock function for the type MockTokenizer
func (_mock *MockTokenizer) Stop(context1 context.Context) error {
	ret := _mock.Called(context1)

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

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

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

// Stop is a helper method to define mock.On call
//   - context1 context.Context
func (_e *MockTokenizer_Expecter) Stop(context1 interface{}) *MockTokenizer_Stop_Call {
	return &MockTokenizer_Stop_Call{Call: _e.mock.On("Stop", context1)}
}

func (_c *MockTokenizer_Stop_Call) Run(run func(context1 context.Context)) *MockTokenizer_Stop_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 *MockTokenizer_Stop_Call) Return(err error) *MockTokenizer_Stop_Call {
	_c.Call.Return(err)
	return _c
}

func (_c *MockTokenizer_Stop_Call) RunAndReturn(run func(context1 context.Context) error) *MockTokenizer_Stop_Call {
	_c.Call.Return(run)
	return _c
}
