mk6i-open-oscar-server/server/oscar/mock_icq_service_test.go

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

package oscar

import (
	"context"

	"github.com/mk6i/open-oscar-server/state"
	"github.com/mk6i/open-oscar-server/wire"
	mock "github.com/stretchr/testify/mock"
)

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

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

	return mock
}

// mockICQService is an autogenerated mock type for the ICQService type
type mockICQService struct {
	mock.Mock
}

type mockICQService_Expecter struct {
	mock *mock.Mock
}

func (_m *mockICQService) EXPECT() *mockICQService_Expecter {
	return &mockICQService_Expecter{mock: &_m.Mock}
}

// DeleteMsgReq provides a mock function for the type mockICQService
func (_mock *mockICQService) DeleteMsgReq(ctx context.Context, instance *state.SessionInstance, seq uint16) error {
	ret := _mock.Called(ctx, instance, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, uint16) error); ok {
		r0 = returnFunc(ctx, instance, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// DeleteMsgReq is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - seq uint16
func (_e *mockICQService_Expecter) DeleteMsgReq(ctx interface{}, instance interface{}, seq interface{}) *mockICQService_DeleteMsgReq_Call {
	return &mockICQService_DeleteMsgReq_Call{Call: _e.mock.On("DeleteMsgReq", ctx, instance, seq)}
}

func (_c *mockICQService_DeleteMsgReq_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, seq uint16)) *mockICQService_DeleteMsgReq_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 uint16
		if args[2] != nil {
			arg2 = args[2].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
		)
	})
	return _c
}

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

func (_c *mockICQService_DeleteMsgReq_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, seq uint16) error) *mockICQService_DeleteMsgReq_Call {
	_c.Call.Return(run)
	return _c
}

// FindByEmail3 provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByEmail3(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByEmail3 is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3
//   - seq uint16
func (_e *mockICQService_Expecter) FindByEmail3(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByEmail3_Call {
	return &mockICQService_FindByEmail3_Call{Call: _e.mock.On("FindByEmail3", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByEmail3_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3, seq uint16)) *mockICQService_FindByEmail3_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByEmail3_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0573_DBQueryMetaReqSearchByEmail3, seq uint16) error) *mockICQService_FindByEmail3_Call {
	_c.Call.Return(run)
	return _c
}

// FindByICQEmail provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByICQEmail(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByICQEmail is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail
//   - seq uint16
func (_e *mockICQService_Expecter) FindByICQEmail(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByICQEmail_Call {
	return &mockICQService_FindByICQEmail_Call{Call: _e.mock.On("FindByICQEmail", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByICQEmail_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail, seq uint16)) *mockICQService_FindByICQEmail_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByICQEmail_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0529_DBQueryMetaReqSearchByEmail, seq uint16) error) *mockICQService_FindByICQEmail_Call {
	_c.Call.Return(run)
	return _c
}

// FindByICQInterests provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByICQInterests(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByICQInterests is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages
//   - seq uint16
func (_e *mockICQService_Expecter) FindByICQInterests(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByICQInterests_Call {
	return &mockICQService_FindByICQInterests_Call{Call: _e.mock.On("FindByICQInterests", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByICQInterests_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages, seq uint16)) *mockICQService_FindByICQInterests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByICQInterests_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0533_DBQueryMetaReqSearchWhitePages, seq uint16) error) *mockICQService_FindByICQInterests_Call {
	_c.Call.Return(run)
	return _c
}

// FindByICQName provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByICQName(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByICQName is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails
//   - seq uint16
func (_e *mockICQService_Expecter) FindByICQName(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByICQName_Call {
	return &mockICQService_FindByICQName_Call{Call: _e.mock.On("FindByICQName", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByICQName_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails, seq uint16)) *mockICQService_FindByICQName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByICQName_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0515_DBQueryMetaReqSearchByDetails, seq uint16) error) *mockICQService_FindByICQName_Call {
	_c.Call.Return(run)
	return _c
}

// FindByUIN provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByUIN(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByUIN is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN
//   - seq uint16
func (_e *mockICQService_Expecter) FindByUIN(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByUIN_Call {
	return &mockICQService_FindByUIN_Call{Call: _e.mock.On("FindByUIN", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByUIN_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, seq uint16)) *mockICQService_FindByUIN_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByUIN_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, seq uint16) error) *mockICQService_FindByUIN_Call {
	_c.Call.Return(run)
	return _c
}

// FindByUIN2 provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByUIN2(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByUIN2 is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2
//   - seq uint16
func (_e *mockICQService_Expecter) FindByUIN2(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByUIN2_Call {
	return &mockICQService_FindByUIN2_Call{Call: _e.mock.On("FindByUIN2", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByUIN2_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2, seq uint16)) *mockICQService_FindByUIN2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByUIN2_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0569_DBQueryMetaReqSearchByUIN2, seq uint16) error) *mockICQService_FindByUIN2_Call {
	_c.Call.Return(run)
	return _c
}

// FindByWhitePages2 provides a mock function for the type mockICQService
func (_mock *mockICQService) FindByWhitePages2(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FindByWhitePages2 is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2
//   - seq uint16
func (_e *mockICQService_Expecter) FindByWhitePages2(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FindByWhitePages2_Call {
	return &mockICQService_FindByWhitePages2_Call{Call: _e.mock.On("FindByWhitePages2", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FindByWhitePages2_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2, seq uint16)) *mockICQService_FindByWhitePages2_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FindByWhitePages2_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x055F_DBQueryMetaReqSearchWhitePages2, seq uint16) error) *mockICQService_FindByWhitePages2_Call {
	_c.Call.Return(run)
	return _c
}

// FullUserInfo provides a mock function for the type mockICQService
func (_mock *mockICQService) FullUserInfo(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// FullUserInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN
//   - seq uint16
func (_e *mockICQService_Expecter) FullUserInfo(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_FullUserInfo_Call {
	return &mockICQService_FullUserInfo_Call{Call: _e.mock.On("FullUserInfo", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_FullUserInfo_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, seq uint16)) *mockICQService_FullUserInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_FullUserInfo_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x051F_DBQueryMetaReqSearchByUIN, seq uint16) error) *mockICQService_FullUserInfo_Call {
	_c.Call.Return(run)
	return _c
}

// OfflineMsgReq provides a mock function for the type mockICQService
func (_mock *mockICQService) OfflineMsgReq(ctx context.Context, inFrame wire.SNACFrame, instance *state.SessionInstance, seq uint16) error {
	ret := _mock.Called(ctx, inFrame, instance, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, wire.SNACFrame, *state.SessionInstance, uint16) error); ok {
		r0 = returnFunc(ctx, inFrame, instance, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// OfflineMsgReq is a helper method to define mock.On call
//   - ctx context.Context
//   - inFrame wire.SNACFrame
//   - instance *state.SessionInstance
//   - seq uint16
func (_e *mockICQService_Expecter) OfflineMsgReq(ctx interface{}, inFrame interface{}, instance interface{}, seq interface{}) *mockICQService_OfflineMsgReq_Call {
	return &mockICQService_OfflineMsgReq_Call{Call: _e.mock.On("OfflineMsgReq", ctx, inFrame, instance, seq)}
}

func (_c *mockICQService_OfflineMsgReq_Call) Run(run func(ctx context.Context, inFrame wire.SNACFrame, instance *state.SessionInstance, seq uint16)) *mockICQService_OfflineMsgReq_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 wire.SNACFrame
		if args[1] != nil {
			arg1 = args[1].(wire.SNACFrame)
		}
		var arg2 *state.SessionInstance
		if args[2] != nil {
			arg2 = args[2].(*state.SessionInstance)
		}
		var arg3 uint16
		if args[3] != nil {
			arg3 = args[3].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
		)
	})
	return _c
}

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

func (_c *mockICQService_OfflineMsgReq_Call) RunAndReturn(run func(ctx context.Context, inFrame wire.SNACFrame, instance *state.SessionInstance, seq uint16) error) *mockICQService_OfflineMsgReq_Call {
	_c.Call.Return(run)
	return _c
}

// SetAffiliations provides a mock function for the type mockICQService
func (_mock *mockICQService) SetAffiliations(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetAffiliations is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations
//   - seq uint16
func (_e *mockICQService_Expecter) SetAffiliations(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetAffiliations_Call {
	return &mockICQService_SetAffiliations_Call{Call: _e.mock.On("SetAffiliations", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetAffiliations_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations, seq uint16)) *mockICQService_SetAffiliations_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetAffiliations_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x041A_DBQueryMetaReqSetAffiliations, seq uint16) error) *mockICQService_SetAffiliations_Call {
	_c.Call.Return(run)
	return _c
}

// SetBasicInfo provides a mock function for the type mockICQService
func (_mock *mockICQService) SetBasicInfo(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetBasicInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo
//   - seq uint16
func (_e *mockICQService_Expecter) SetBasicInfo(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetBasicInfo_Call {
	return &mockICQService_SetBasicInfo_Call{Call: _e.mock.On("SetBasicInfo", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetBasicInfo_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo, seq uint16)) *mockICQService_SetBasicInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetBasicInfo_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03EA_DBQueryMetaReqSetBasicInfo, seq uint16) error) *mockICQService_SetBasicInfo_Call {
	_c.Call.Return(run)
	return _c
}

// SetEmails provides a mock function for the type mockICQService
func (_mock *mockICQService) SetEmails(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetEmails is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails
//   - seq uint16
func (_e *mockICQService_Expecter) SetEmails(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetEmails_Call {
	return &mockICQService_SetEmails_Call{Call: _e.mock.On("SetEmails", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetEmails_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails, seq uint16)) *mockICQService_SetEmails_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetEmails_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x040B_DBQueryMetaReqSetEmails, seq uint16) error) *mockICQService_SetEmails_Call {
	_c.Call.Return(run)
	return _c
}

// SetICQInfo provides a mock function for the type mockICQService
func (_mock *mockICQService) SetICQInfo(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetICQInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo
//   - seq uint16
func (_e *mockICQService_Expecter) SetICQInfo(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetICQInfo_Call {
	return &mockICQService_SetICQInfo_Call{Call: _e.mock.On("SetICQInfo", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetICQInfo_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo, seq uint16)) *mockICQService_SetICQInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetICQInfo_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0C3A_DBQueryMetaReqSetFullInfo, seq uint16) error) *mockICQService_SetICQInfo_Call {
	_c.Call.Return(run)
	return _c
}

// SetICQPhone provides a mock function for the type mockICQService
func (_mock *mockICQService) SetICQPhone(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetICQPhone is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone
//   - seq uint16
func (_e *mockICQService_Expecter) SetICQPhone(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetICQPhone_Call {
	return &mockICQService_SetICQPhone_Call{Call: _e.mock.On("SetICQPhone", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetICQPhone_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone, seq uint16)) *mockICQService_SetICQPhone_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetICQPhone_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0654_DBQueryMetaReqSetICQPhone, seq uint16) error) *mockICQService_SetICQPhone_Call {
	_c.Call.Return(run)
	return _c
}

// SetInterests provides a mock function for the type mockICQService
func (_mock *mockICQService) SetInterests(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetInterests is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests
//   - seq uint16
func (_e *mockICQService_Expecter) SetInterests(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetInterests_Call {
	return &mockICQService_SetInterests_Call{Call: _e.mock.On("SetInterests", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetInterests_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests, seq uint16)) *mockICQService_SetInterests_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetInterests_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0410_DBQueryMetaReqSetInterests, seq uint16) error) *mockICQService_SetInterests_Call {
	_c.Call.Return(run)
	return _c
}

// SetMoreInfo provides a mock function for the type mockICQService
func (_mock *mockICQService) SetMoreInfo(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetMoreInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo
//   - seq uint16
func (_e *mockICQService_Expecter) SetMoreInfo(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetMoreInfo_Call {
	return &mockICQService_SetMoreInfo_Call{Call: _e.mock.On("SetMoreInfo", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetMoreInfo_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo, seq uint16)) *mockICQService_SetMoreInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetMoreInfo_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03FD_DBQueryMetaReqSetMoreInfo, seq uint16) error) *mockICQService_SetMoreInfo_Call {
	_c.Call.Return(run)
	return _c
}

// SetPermissions provides a mock function for the type mockICQService
func (_mock *mockICQService) SetPermissions(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetPermissions is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions
//   - seq uint16
func (_e *mockICQService_Expecter) SetPermissions(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetPermissions_Call {
	return &mockICQService_SetPermissions_Call{Call: _e.mock.On("SetPermissions", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetPermissions_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions, seq uint16)) *mockICQService_SetPermissions_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetPermissions_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0424_DBQueryMetaReqSetPermissions, seq uint16) error) *mockICQService_SetPermissions_Call {
	_c.Call.Return(run)
	return _c
}

// SetUserNotes provides a mock function for the type mockICQService
func (_mock *mockICQService) SetUserNotes(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetUserNotes is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes
//   - seq uint16
func (_e *mockICQService_Expecter) SetUserNotes(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetUserNotes_Call {
	return &mockICQService_SetUserNotes_Call{Call: _e.mock.On("SetUserNotes", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetUserNotes_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes, seq uint16)) *mockICQService_SetUserNotes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetUserNotes_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0406_DBQueryMetaReqSetNotes, seq uint16) error) *mockICQService_SetUserNotes_Call {
	_c.Call.Return(run)
	return _c
}

// SetWorkInfo provides a mock function for the type mockICQService
func (_mock *mockICQService) SetWorkInfo(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// SetWorkInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo
//   - seq uint16
func (_e *mockICQService_Expecter) SetWorkInfo(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_SetWorkInfo_Call {
	return &mockICQService_SetWorkInfo_Call{Call: _e.mock.On("SetWorkInfo", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_SetWorkInfo_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo, seq uint16)) *mockICQService_SetWorkInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_SetWorkInfo_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x03F3_DBQueryMetaReqSetWorkInfo, seq uint16) error) *mockICQService_SetWorkInfo_Call {
	_c.Call.Return(run)
	return _c
}

// ShortUserInfo provides a mock function for the type mockICQService
func (_mock *mockICQService) ShortUserInfo(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// ShortUserInfo is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo
//   - seq uint16
func (_e *mockICQService_Expecter) ShortUserInfo(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_ShortUserInfo_Call {
	return &mockICQService_ShortUserInfo_Call{Call: _e.mock.On("ShortUserInfo", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_ShortUserInfo_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo, seq uint16)) *mockICQService_ShortUserInfo_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_ShortUserInfo_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x04BA_DBQueryMetaReqShortInfo, seq uint16) error) *mockICQService_ShortUserInfo_Call {
	_c.Call.Return(run)
	return _c
}

// XMLReqData provides a mock function for the type mockICQService
func (_mock *mockICQService) XMLReqData(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq, seq uint16) error {
	ret := _mock.Called(ctx, instance, inFrame, inBody, seq)

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

	var r0 error
	if returnFunc, ok := ret.Get(0).(func(context.Context, *state.SessionInstance, wire.SNACFrame, wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq, uint16) error); ok {
		r0 = returnFunc(ctx, instance, inFrame, inBody, seq)
	} else {
		r0 = ret.Error(0)
	}
	return r0
}

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

// XMLReqData is a helper method to define mock.On call
//   - ctx context.Context
//   - instance *state.SessionInstance
//   - inFrame wire.SNACFrame
//   - inBody wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq
//   - seq uint16
func (_e *mockICQService_Expecter) XMLReqData(ctx interface{}, instance interface{}, inFrame interface{}, inBody interface{}, seq interface{}) *mockICQService_XMLReqData_Call {
	return &mockICQService_XMLReqData_Call{Call: _e.mock.On("XMLReqData", ctx, instance, inFrame, inBody, seq)}
}

func (_c *mockICQService_XMLReqData_Call) Run(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq, seq uint16)) *mockICQService_XMLReqData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 context.Context
		if args[0] != nil {
			arg0 = args[0].(context.Context)
		}
		var arg1 *state.SessionInstance
		if args[1] != nil {
			arg1 = args[1].(*state.SessionInstance)
		}
		var arg2 wire.SNACFrame
		if args[2] != nil {
			arg2 = args[2].(wire.SNACFrame)
		}
		var arg3 wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq
		if args[3] != nil {
			arg3 = args[3].(wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq)
		}
		var arg4 uint16
		if args[4] != nil {
			arg4 = args[4].(uint16)
		}
		run(
			arg0,
			arg1,
			arg2,
			arg3,
			arg4,
		)
	})
	return _c
}

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

func (_c *mockICQService_XMLReqData_Call) RunAndReturn(run func(ctx context.Context, instance *state.SessionInstance, inFrame wire.SNACFrame, inBody wire.ICQ_0x07D0_0x0898_DBQueryMetaReqXMLReq, seq uint16) error) *mockICQService_XMLReqData_Call {
	_c.Call.Return(run)
	return _c
}