// Code generated by mockery v2.50.0. DO NOT EDIT.

package mocks

import (
	context "context"

	runtime "github.com/heroiclabs/nakama-common/runtime"
	mock "github.com/stretchr/testify/mock"
)

// MockSatori is an autogenerated mock type for the Satori type
type MockSatori struct {
	mock.Mock
}

type MockSatori_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSatori) EXPECT() *MockSatori_Expecter {
	return &MockSatori_Expecter{mock: &_m.Mock}
}

// Authenticate provides a mock function with given fields: ctx, id, defaultProperties, customProperties, ipAddress
func (_m *MockSatori) Authenticate(ctx context.Context, id string, defaultProperties map[string]string, customProperties map[string]string, ipAddress ...string) error {
	_va := make([]interface{}, len(ipAddress))
	for _i := range ipAddress {
		_va[_i] = ipAddress[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id, defaultProperties, customProperties)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, map[string]string, map[string]string, ...string) error); ok {
		r0 = rf(ctx, id, defaultProperties, customProperties, ipAddress...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// Authenticate is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - defaultProperties map[string]string
//   - customProperties map[string]string
//   - ipAddress ...string
func (_e *MockSatori_Expecter) Authenticate(ctx interface{}, id interface{}, defaultProperties interface{}, customProperties interface{}, ipAddress ...interface{}) *MockSatori_Authenticate_Call {
	return &MockSatori_Authenticate_Call{Call: _e.mock.On("Authenticate",
		append([]interface{}{ctx, id, defaultProperties, customProperties}, ipAddress...)...)}
}

func (_c *MockSatori_Authenticate_Call) Run(run func(ctx context.Context, id string, defaultProperties map[string]string, customProperties map[string]string, ipAddress ...string)) *MockSatori_Authenticate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-4)
		for i, a := range args[4:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(context.Context), args[1].(string), args[2].(map[string]string), args[3].(map[string]string), variadicArgs...)
	})
	return _c
}

func (_c *MockSatori_Authenticate_Call) Return(_a0 error) *MockSatori_Authenticate_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// EventsPublish provides a mock function with given fields: ctx, id, events
func (_m *MockSatori) EventsPublish(ctx context.Context, id string, events []*runtime.Event) error {
	ret := _m.Called(ctx, id, events)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, []*runtime.Event) error); ok {
		r0 = rf(ctx, id, events)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// EventsPublish is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - events []*runtime.Event
func (_e *MockSatori_Expecter) EventsPublish(ctx interface{}, id interface{}, events interface{}) *MockSatori_EventsPublish_Call {
	return &MockSatori_EventsPublish_Call{Call: _e.mock.On("EventsPublish", ctx, id, events)}
}

func (_c *MockSatori_EventsPublish_Call) Run(run func(ctx context.Context, id string, events []*runtime.Event)) *MockSatori_EventsPublish_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].([]*runtime.Event))
	})
	return _c
}

func (_c *MockSatori_EventsPublish_Call) Return(_a0 error) *MockSatori_EventsPublish_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// ExperimentsList provides a mock function with given fields: ctx, id, names
func (_m *MockSatori) ExperimentsList(ctx context.Context, id string, names ...string) (*runtime.ExperimentList, error) {
	_va := make([]interface{}, len(names))
	for _i := range names {
		_va[_i] = names[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *runtime.ExperimentList
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (*runtime.ExperimentList, error)); ok {
		return rf(ctx, id, names...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *runtime.ExperimentList); ok {
		r0 = rf(ctx, id, names...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*runtime.ExperimentList)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...string) error); ok {
		r1 = rf(ctx, id, names...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// ExperimentsList is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - names ...string
func (_e *MockSatori_Expecter) ExperimentsList(ctx interface{}, id interface{}, names ...interface{}) *MockSatori_ExperimentsList_Call {
	return &MockSatori_ExperimentsList_Call{Call: _e.mock.On("ExperimentsList",
		append([]interface{}{ctx, id}, names...)...)}
}

func (_c *MockSatori_ExperimentsList_Call) Run(run func(ctx context.Context, id string, names ...string)) *MockSatori_ExperimentsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockSatori_ExperimentsList_Call) Return(_a0 *runtime.ExperimentList, _a1 error) *MockSatori_ExperimentsList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSatori_ExperimentsList_Call) RunAndReturn(run func(context.Context, string, ...string) (*runtime.ExperimentList, error)) *MockSatori_ExperimentsList_Call {
	_c.Call.Return(run)
	return _c
}

// FlagsList provides a mock function with given fields: ctx, id, names
func (_m *MockSatori) FlagsList(ctx context.Context, id string, names ...string) (*runtime.FlagList, error) {
	_va := make([]interface{}, len(names))
	for _i := range names {
		_va[_i] = names[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *runtime.FlagList
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (*runtime.FlagList, error)); ok {
		return rf(ctx, id, names...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *runtime.FlagList); ok {
		r0 = rf(ctx, id, names...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*runtime.FlagList)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...string) error); ok {
		r1 = rf(ctx, id, names...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// FlagsList is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - names ...string
func (_e *MockSatori_Expecter) FlagsList(ctx interface{}, id interface{}, names ...interface{}) *MockSatori_FlagsList_Call {
	return &MockSatori_FlagsList_Call{Call: _e.mock.On("FlagsList",
		append([]interface{}{ctx, id}, names...)...)}
}

func (_c *MockSatori_FlagsList_Call) Run(run func(ctx context.Context, id string, names ...string)) *MockSatori_FlagsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockSatori_FlagsList_Call) Return(_a0 *runtime.FlagList, _a1 error) *MockSatori_FlagsList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSatori_FlagsList_Call) RunAndReturn(run func(context.Context, string, ...string) (*runtime.FlagList, error)) *MockSatori_FlagsList_Call {
	_c.Call.Return(run)
	return _c
}

// LiveEventsList provides a mock function with given fields: ctx, id, names
func (_m *MockSatori) LiveEventsList(ctx context.Context, id string, names ...string) (*runtime.LiveEventList, error) {
	_va := make([]interface{}, len(names))
	for _i := range names {
		_va[_i] = names[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, id)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *runtime.LiveEventList
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) (*runtime.LiveEventList, error)); ok {
		return rf(ctx, id, names...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, ...string) *runtime.LiveEventList); ok {
		r0 = rf(ctx, id, names...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*runtime.LiveEventList)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, ...string) error); ok {
		r1 = rf(ctx, id, names...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// LiveEventsList is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - names ...string
func (_e *MockSatori_Expecter) LiveEventsList(ctx interface{}, id interface{}, names ...interface{}) *MockSatori_LiveEventsList_Call {
	return &MockSatori_LiveEventsList_Call{Call: _e.mock.On("LiveEventsList",
		append([]interface{}{ctx, id}, names...)...)}
}

func (_c *MockSatori_LiveEventsList_Call) Run(run func(ctx context.Context, id string, names ...string)) *MockSatori_LiveEventsList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]string, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(string)
			}
		}
		run(args[0].(context.Context), args[1].(string), variadicArgs...)
	})
	return _c
}

func (_c *MockSatori_LiveEventsList_Call) Return(_a0 *runtime.LiveEventList, _a1 error) *MockSatori_LiveEventsList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSatori_LiveEventsList_Call) RunAndReturn(run func(context.Context, string, ...string) (*runtime.LiveEventList, error)) *MockSatori_LiveEventsList_Call {
	_c.Call.Return(run)
	return _c
}

// MessageDelete provides a mock function with given fields: ctx, id, messageId
func (_m *MockSatori) MessageDelete(ctx context.Context, id string, messageId string) error {
	ret := _m.Called(ctx, id, messageId)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
		r0 = rf(ctx, id, messageId)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// MessageDelete is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - messageId string
func (_e *MockSatori_Expecter) MessageDelete(ctx interface{}, id interface{}, messageId interface{}) *MockSatori_MessageDelete_Call {
	return &MockSatori_MessageDelete_Call{Call: _e.mock.On("MessageDelete", ctx, id, messageId)}
}

func (_c *MockSatori_MessageDelete_Call) Run(run func(ctx context.Context, id string, messageId string)) *MockSatori_MessageDelete_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string))
	})
	return _c
}

func (_c *MockSatori_MessageDelete_Call) Return(_a0 error) *MockSatori_MessageDelete_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// MessageUpdate provides a mock function with given fields: ctx, id, messageId, readTime, consumeTime
func (_m *MockSatori) MessageUpdate(ctx context.Context, id string, messageId string, readTime int64, consumeTime int64) error {
	ret := _m.Called(ctx, id, messageId, readTime, consumeTime)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, string, int64, int64) error); ok {
		r0 = rf(ctx, id, messageId, readTime, consumeTime)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// MessageUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - messageId string
//   - readTime int64
//   - consumeTime int64
func (_e *MockSatori_Expecter) MessageUpdate(ctx interface{}, id interface{}, messageId interface{}, readTime interface{}, consumeTime interface{}) *MockSatori_MessageUpdate_Call {
	return &MockSatori_MessageUpdate_Call{Call: _e.mock.On("MessageUpdate", ctx, id, messageId, readTime, consumeTime)}
}

func (_c *MockSatori_MessageUpdate_Call) Run(run func(ctx context.Context, id string, messageId string, readTime int64, consumeTime int64)) *MockSatori_MessageUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(string), args[3].(int64), args[4].(int64))
	})
	return _c
}

func (_c *MockSatori_MessageUpdate_Call) Return(_a0 error) *MockSatori_MessageUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

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

// MessagesList provides a mock function with given fields: ctx, id, limit, forward, cursor
func (_m *MockSatori) MessagesList(ctx context.Context, id string, limit int, forward bool, cursor string) (*runtime.MessageList, error) {
	ret := _m.Called(ctx, id, limit, forward, cursor)

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

	var r0 *runtime.MessageList
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, string, int, bool, string) (*runtime.MessageList, error)); ok {
		return rf(ctx, id, limit, forward, cursor)
	}
	if rf, ok := ret.Get(0).(func(context.Context, string, int, bool, string) *runtime.MessageList); ok {
		r0 = rf(ctx, id, limit, forward, cursor)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*runtime.MessageList)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, string, int, bool, string) error); ok {
		r1 = rf(ctx, id, limit, forward, cursor)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// MessagesList is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - limit int
//   - forward bool
//   - cursor string
func (_e *MockSatori_Expecter) MessagesList(ctx interface{}, id interface{}, limit interface{}, forward interface{}, cursor interface{}) *MockSatori_MessagesList_Call {
	return &MockSatori_MessagesList_Call{Call: _e.mock.On("MessagesList", ctx, id, limit, forward, cursor)}
}

func (_c *MockSatori_MessagesList_Call) Run(run func(ctx context.Context, id string, limit int, forward bool, cursor string)) *MockSatori_MessagesList_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(int), args[3].(bool), args[4].(string))
	})
	return _c
}

func (_c *MockSatori_MessagesList_Call) Return(_a0 *runtime.MessageList, _a1 error) *MockSatori_MessagesList_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSatori_MessagesList_Call) RunAndReturn(run func(context.Context, string, int, bool, string) (*runtime.MessageList, error)) *MockSatori_MessagesList_Call {
	_c.Call.Return(run)
	return _c
}

// PropertiesGet provides a mock function with given fields: ctx, id
func (_m *MockSatori) PropertiesGet(ctx context.Context, id string) (*runtime.Properties, error) {
	ret := _m.Called(ctx, id)

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

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

	if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
		r1 = rf(ctx, id)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// PropertiesGet is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
func (_e *MockSatori_Expecter) PropertiesGet(ctx interface{}, id interface{}) *MockSatori_PropertiesGet_Call {
	return &MockSatori_PropertiesGet_Call{Call: _e.mock.On("PropertiesGet", ctx, id)}
}

func (_c *MockSatori_PropertiesGet_Call) Run(run func(ctx context.Context, id string)) *MockSatori_PropertiesGet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string))
	})
	return _c
}

func (_c *MockSatori_PropertiesGet_Call) Return(_a0 *runtime.Properties, _a1 error) *MockSatori_PropertiesGet_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockSatori_PropertiesGet_Call) RunAndReturn(run func(context.Context, string) (*runtime.Properties, error)) *MockSatori_PropertiesGet_Call {
	_c.Call.Return(run)
	return _c
}

// PropertiesUpdate provides a mock function with given fields: ctx, id, properties
func (_m *MockSatori) PropertiesUpdate(ctx context.Context, id string, properties *runtime.PropertiesUpdate) error {
	ret := _m.Called(ctx, id, properties)

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

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, string, *runtime.PropertiesUpdate) error); ok {
		r0 = rf(ctx, id, properties)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

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

// PropertiesUpdate is a helper method to define mock.On call
//   - ctx context.Context
//   - id string
//   - properties *runtime.PropertiesUpdate
func (_e *MockSatori_Expecter) PropertiesUpdate(ctx interface{}, id interface{}, properties interface{}) *MockSatori_PropertiesUpdate_Call {
	return &MockSatori_PropertiesUpdate_Call{Call: _e.mock.On("PropertiesUpdate", ctx, id, properties)}
}

func (_c *MockSatori_PropertiesUpdate_Call) Run(run func(ctx context.Context, id string, properties *runtime.PropertiesUpdate)) *MockSatori_PropertiesUpdate_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(context.Context), args[1].(string), args[2].(*runtime.PropertiesUpdate))
	})
	return _c
}

func (_c *MockSatori_PropertiesUpdate_Call) Return(_a0 error) *MockSatori_PropertiesUpdate_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockSatori_PropertiesUpdate_Call) RunAndReturn(run func(context.Context, string, *runtime.PropertiesUpdate) error) *MockSatori_PropertiesUpdate_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}
