func (m *MockSession) String(arg0 string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "String", arg0)
	ret0, _ := ret[0].(string)
	return ret0
}
String mocks base method
package mocks
import (
	context "context"
	gomock "github.com/golang/mock/gomock"
	nats "github.com/nats-io/nats.go"
	networkentity "github.com/topfreegames/pitaya/v2/networkentity"
	session "github.com/topfreegames/pitaya/v2/session"
	net "net"
	reflect "reflect"
)
type MockSession struct {
	ctrl     *gomock.Controller
	recorder *MockSessionMockRecorder
}
type MockSessionMockRecorder struct {
	mock *MockSession
}
func NewMockSession(ctrl *gomock.Controller) *MockSession {
	mock := &MockSession{ctrl: ctrl}
	mock.recorder = &MockSessionMockRecorder{mock}
	return mock
}
func (m *MockSession) EXPECT() *MockSessionMockRecorder {
	return m.recorder
}
func (m *MockSession) Bind(arg0 context.Context, arg1 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bind", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) Bind(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bind", reflect.TypeOf((*MockSession)(nil).Bind), arg0, arg1)
}
func (m *MockSession) Clear() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Clear")
}
func (mr *MockSessionMockRecorder) Clear() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Clear", reflect.TypeOf((*MockSession)(nil).Clear))
}
func (m *MockSession) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}
func (mr *MockSessionMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockSession)(nil).Close))
}
func (m *MockSession) Float32(arg0 string) float32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Float32", arg0)
	ret0, _ := ret[0].(float32)
	return ret0
}
func (mr *MockSessionMockRecorder) Float32(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float32", reflect.TypeOf((*MockSession)(nil).Float32), arg0)
}
func (m *MockSession) Float64(arg0 string) float64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Float64", arg0)
	ret0, _ := ret[0].(float64)
	return ret0
}
func (mr *MockSessionMockRecorder) Float64(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Float64", reflect.TypeOf((*MockSession)(nil).Float64), arg0)
}
func (m *MockSession) Get(arg0 string) interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", arg0)
	ret0, _ := ret[0].(interface{})
	return ret0
}
func (mr *MockSessionMockRecorder) Get(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockSession)(nil).Get), arg0)
}
func (m *MockSession) GetData() map[string]interface{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetData")
	ret0, _ := ret[0].(map[string]interface{})
	return ret0
}
func (mr *MockSessionMockRecorder) GetData() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetData", reflect.TypeOf((*MockSession)(nil).GetData))
}
func (m *MockSession) GetDataEncoded() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetDataEncoded")
	ret0, _ := ret[0].([]byte)
	return ret0
}
func (mr *MockSessionMockRecorder) GetDataEncoded() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDataEncoded", reflect.TypeOf((*MockSession)(nil).GetDataEncoded))
}
func (m *MockSession) GetHandshakeData() *session.HandshakeData {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetHandshakeData")
	ret0, _ := ret[0].(*session.HandshakeData)
	return ret0
}
func (mr *MockSessionMockRecorder) GetHandshakeData() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHandshakeData", reflect.TypeOf((*MockSession)(nil).GetHandshakeData))
}
func (m *MockSession) GetIsFrontend() bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetIsFrontend")
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockSessionMockRecorder) GetIsFrontend() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIsFrontend", reflect.TypeOf((*MockSession)(nil).GetIsFrontend))
}
func (m *MockSession) GetOnCloseCallbacks() []func() {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetOnCloseCallbacks")
	ret0, _ := ret[0].([]func())
	return ret0
}
func (mr *MockSessionMockRecorder) GetOnCloseCallbacks() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOnCloseCallbacks", reflect.TypeOf((*MockSession)(nil).GetOnCloseCallbacks))
}
func (m *MockSession) GetSubscriptions() []*nats.Subscription {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubscriptions")
	ret0, _ := ret[0].([]*nats.Subscription)
	return ret0
}
func (mr *MockSessionMockRecorder) GetSubscriptions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptions", reflect.TypeOf((*MockSession)(nil).GetSubscriptions))
}
func (m *MockSession) HasKey(arg0 string) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasKey", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}
func (mr *MockSessionMockRecorder) HasKey(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HasKey", reflect.TypeOf((*MockSession)(nil).HasKey), arg0)
}
func (m *MockSession) ID() int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ID")
	ret0, _ := ret[0].(int64)
	return ret0
}
func (mr *MockSessionMockRecorder) ID() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockSession)(nil).ID))
}
func (m *MockSession) Int(arg0 string) int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Int", arg0)
	ret0, _ := ret[0].(int)
	return ret0
}
func (mr *MockSessionMockRecorder) Int(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int", reflect.TypeOf((*MockSession)(nil).Int), arg0)
}
func (m *MockSession) Int16(arg0 string) int16 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Int16", arg0)
	ret0, _ := ret[0].(int16)
	return ret0
}
func (mr *MockSessionMockRecorder) Int16(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int16", reflect.TypeOf((*MockSession)(nil).Int16), arg0)
}
func (m *MockSession) Int32(arg0 string) int32 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Int32", arg0)
	ret0, _ := ret[0].(int32)
	return ret0
}
func (mr *MockSessionMockRecorder) Int32(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int32", reflect.TypeOf((*MockSession)(nil).Int32), arg0)
}
func (m *MockSession) Int64(arg0 string) int64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Int64", arg0)
	ret0, _ := ret[0].(int64)
	return ret0
}
func (mr *MockSessionMockRecorder) Int64(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int64", reflect.TypeOf((*MockSession)(nil).Int64), arg0)
}
func (m *MockSession) Int8(arg0 string) int8 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Int8", arg0)
	ret0, _ := ret[0].(int8)
	return ret0
}
func (mr *MockSessionMockRecorder) Int8(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Int8", reflect.TypeOf((*MockSession)(nil).Int8), arg0)
}
func (m *MockSession) Kick(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Kick", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) Kick(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kick", reflect.TypeOf((*MockSession)(nil).Kick), arg0)
}
func (m *MockSession) OnClose(arg0 func()) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OnClose", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) OnClose(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnClose", reflect.TypeOf((*MockSession)(nil).OnClose), arg0)
}
func (m *MockSession) Push(arg0 string, arg1 interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Push", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) Push(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Push", reflect.TypeOf((*MockSession)(nil).Push), arg0, arg1)
}
func (m *MockSession) PushToFront(arg0 context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PushToFront", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) PushToFront(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PushToFront", reflect.TypeOf((*MockSession)(nil).PushToFront), arg0)
}
func (m *MockSession) RemoteAddr() net.Addr {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoteAddr")
	ret0, _ := ret[0].(net.Addr)
	return ret0
}
func (mr *MockSessionMockRecorder) RemoteAddr() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockSession)(nil).RemoteAddr))
}
func (m *MockSession) Remove(arg0 string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Remove", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) Remove(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Remove", reflect.TypeOf((*MockSession)(nil).Remove), arg0)
}
func (m *MockSession) ResponseMID(arg0 context.Context, arg1 uint, arg2 interface{}, arg3 ...bool) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResponseMID", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) ResponseMID(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResponseMID", reflect.TypeOf((*MockSession)(nil).ResponseMID), varargs...)
}
func (m *MockSession) Set(arg0 string, arg1 interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Set", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) Set(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Set", reflect.TypeOf((*MockSession)(nil).Set), arg0, arg1)
}
func (m *MockSession) SetData(arg0 map[string]interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetData", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) SetData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetData", reflect.TypeOf((*MockSession)(nil).SetData), arg0)
}
func (m *MockSession) SetDataEncoded(arg0 []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDataEncoded", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}
func (mr *MockSessionMockRecorder) SetDataEncoded(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDataEncoded", reflect.TypeOf((*MockSession)(nil).SetDataEncoded), arg0)
}
func (m *MockSession) SetFrontendData(arg0 string, arg1 int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetFrontendData", arg0, arg1)
}
func (mr *MockSessionMockRecorder) SetFrontendData(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetFrontendData", reflect.TypeOf((*MockSession)(nil).SetFrontendData), arg0, arg1)
}
func (m *MockSession) SetHandshakeData(arg0 *session.HandshakeData) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetHandshakeData", arg0)
}
func (mr *MockSessionMockRecorder) SetHandshakeData(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHandshakeData", reflect.TypeOf((*MockSession)(nil).SetHandshakeData), arg0)
}
func (m *MockSession) SetIsFrontend(arg0 bool) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetIsFrontend", arg0)
}
func (mr *MockSessionMockRecorder) SetIsFrontend(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsFrontend", reflect.TypeOf((*MockSession)(nil).SetIsFrontend), arg0)
}
func (m *MockSession) SetOnCloseCallbacks(arg0 []func()) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOnCloseCallbacks", arg0)
}
func (mr *MockSessionMockRecorder) SetOnCloseCallbacks(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOnCloseCallbacks", reflect.TypeOf((*MockSession)(nil).SetOnCloseCallbacks), arg0)
}
func (m *MockSession) SetSubscriptions(arg0 []*nats.Subscription) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSubscriptions", arg0)
}
func (mr *MockSessionMockRecorder) SetSubscriptions(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSubscriptions", reflect.TypeOf((*MockSession)(nil).SetSubscriptions), arg0)
}