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

package sale_order_mock

import (
	context "context"

	grpc "google.golang.org/grpc"

	mock "github.com/stretchr/testify/mock"

	sov1 "github.com/AlchemyTelcoSolutions/proto/gen/go/callisto/so/v1"
)

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

type SOServiceClient_Expecter struct {
	mock *mock.Mock
}

func (_m *SOServiceClient) EXPECT() *SOServiceClient_Expecter {
	return &SOServiceClient_Expecter{mock: &_m.Mock}
}

// AddApproval provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) AddApproval(ctx context.Context, re *sov1.AddApprovalRequest, opts ...grpc.CallOption) (*sov1.AddApprovalResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.AddApprovalResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddApprovalRequest, ...grpc.CallOption) (*sov1.AddApprovalResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddApprovalRequest, ...grpc.CallOption) *sov1.AddApprovalResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.AddApprovalResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.AddApprovalRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddApproval is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.AddApprovalRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) AddApproval(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_AddApproval_Call {
	return &SOServiceClient_AddApproval_Call{Call: _e.mock.On("AddApproval",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_AddApproval_Call) Run(run func(ctx context.Context, re *sov1.AddApprovalRequest, opts ...grpc.CallOption)) *SOServiceClient_AddApproval_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.AddApprovalRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_AddApproval_Call) Return(_a0 *sov1.AddApprovalResponse, _a1 error) *SOServiceClient_AddApproval_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_AddApproval_Call) RunAndReturn(run func(context.Context, *sov1.AddApprovalRequest, ...grpc.CallOption) (*sov1.AddApprovalResponse, error)) *SOServiceClient_AddApproval_Call {
	_c.Call.Return(run)
	return _c
}

// AddAsn provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) AddAsn(ctx context.Context, re *sov1.AddAsnRequest, opts ...grpc.CallOption) (*sov1.AddAsnResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.AddAsnResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddAsnRequest, ...grpc.CallOption) (*sov1.AddAsnResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddAsnRequest, ...grpc.CallOption) *sov1.AddAsnResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.AddAsnResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.AddAsnRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddAsn is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.AddAsnRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) AddAsn(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_AddAsn_Call {
	return &SOServiceClient_AddAsn_Call{Call: _e.mock.On("AddAsn",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_AddAsn_Call) Run(run func(ctx context.Context, re *sov1.AddAsnRequest, opts ...grpc.CallOption)) *SOServiceClient_AddAsn_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.AddAsnRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_AddAsn_Call) Return(_a0 *sov1.AddAsnResponse, _a1 error) *SOServiceClient_AddAsn_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_AddAsn_Call) RunAndReturn(run func(context.Context, *sov1.AddAsnRequest, ...grpc.CallOption) (*sov1.AddAsnResponse, error)) *SOServiceClient_AddAsn_Call {
	_c.Call.Return(run)
	return _c
}

// AddDocument provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) AddDocument(ctx context.Context, re *sov1.AddDocumentRequest, opts ...grpc.CallOption) (*sov1.AddDocumentResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.AddDocumentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddDocumentRequest, ...grpc.CallOption) (*sov1.AddDocumentResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddDocumentRequest, ...grpc.CallOption) *sov1.AddDocumentResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.AddDocumentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.AddDocumentRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddDocument is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.AddDocumentRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) AddDocument(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_AddDocument_Call {
	return &SOServiceClient_AddDocument_Call{Call: _e.mock.On("AddDocument",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_AddDocument_Call) Run(run func(ctx context.Context, re *sov1.AddDocumentRequest, opts ...grpc.CallOption)) *SOServiceClient_AddDocument_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.AddDocumentRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_AddDocument_Call) Return(_a0 *sov1.AddDocumentResponse, _a1 error) *SOServiceClient_AddDocument_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_AddDocument_Call) RunAndReturn(run func(context.Context, *sov1.AddDocumentRequest, ...grpc.CallOption) (*sov1.AddDocumentResponse, error)) *SOServiceClient_AddDocument_Call {
	_c.Call.Return(run)
	return _c
}

// AddNote provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) AddNote(ctx context.Context, re *sov1.AddNoteRequest, opts ...grpc.CallOption) (*sov1.AddNoteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.AddNoteResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddNoteRequest, ...grpc.CallOption) (*sov1.AddNoteResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddNoteRequest, ...grpc.CallOption) *sov1.AddNoteResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.AddNoteResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.AddNoteRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddNote is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.AddNoteRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) AddNote(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_AddNote_Call {
	return &SOServiceClient_AddNote_Call{Call: _e.mock.On("AddNote",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_AddNote_Call) Run(run func(ctx context.Context, re *sov1.AddNoteRequest, opts ...grpc.CallOption)) *SOServiceClient_AddNote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.AddNoteRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_AddNote_Call) Return(_a0 *sov1.AddNoteResponse, _a1 error) *SOServiceClient_AddNote_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_AddNote_Call) RunAndReturn(run func(context.Context, *sov1.AddNoteRequest, ...grpc.CallOption) (*sov1.AddNoteResponse, error)) *SOServiceClient_AddNote_Call {
	_c.Call.Return(run)
	return _c
}

// AddShipment provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) AddShipment(ctx context.Context, re *sov1.AddShipmentRequest, opts ...grpc.CallOption) (*sov1.AddShipmentResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.AddShipmentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddShipmentRequest, ...grpc.CallOption) (*sov1.AddShipmentResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.AddShipmentRequest, ...grpc.CallOption) *sov1.AddShipmentResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.AddShipmentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.AddShipmentRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// AddShipment is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.AddShipmentRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) AddShipment(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_AddShipment_Call {
	return &SOServiceClient_AddShipment_Call{Call: _e.mock.On("AddShipment",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_AddShipment_Call) Run(run func(ctx context.Context, re *sov1.AddShipmentRequest, opts ...grpc.CallOption)) *SOServiceClient_AddShipment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.AddShipmentRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_AddShipment_Call) Return(_a0 *sov1.AddShipmentResponse, _a1 error) *SOServiceClient_AddShipment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_AddShipment_Call) RunAndReturn(run func(context.Context, *sov1.AddShipmentRequest, ...grpc.CallOption) (*sov1.AddShipmentResponse, error)) *SOServiceClient_AddShipment_Call {
	_c.Call.Return(run)
	return _c
}

// CheckOrderAffiliation provides a mock function with given fields: ctx, in, opts
func (_m *SOServiceClient) CheckOrderAffiliation(ctx context.Context, in *sov1.CheckOrderAffiliationRequest, opts ...grpc.CallOption) (*sov1.CheckOrderAffiliationResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.CheckOrderAffiliationResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.CheckOrderAffiliationRequest, ...grpc.CallOption) (*sov1.CheckOrderAffiliationResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.CheckOrderAffiliationRequest, ...grpc.CallOption) *sov1.CheckOrderAffiliationResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.CheckOrderAffiliationResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.CheckOrderAffiliationRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CheckOrderAffiliation is a helper method to define mock.On call
//   - ctx context.Context
//   - in *sov1.CheckOrderAffiliationRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) CheckOrderAffiliation(ctx interface{}, in interface{}, opts ...interface{}) *SOServiceClient_CheckOrderAffiliation_Call {
	return &SOServiceClient_CheckOrderAffiliation_Call{Call: _e.mock.On("CheckOrderAffiliation",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *SOServiceClient_CheckOrderAffiliation_Call) Run(run func(ctx context.Context, in *sov1.CheckOrderAffiliationRequest, opts ...grpc.CallOption)) *SOServiceClient_CheckOrderAffiliation_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.CheckOrderAffiliationRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_CheckOrderAffiliation_Call) Return(_a0 *sov1.CheckOrderAffiliationResponse, _a1 error) *SOServiceClient_CheckOrderAffiliation_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_CheckOrderAffiliation_Call) RunAndReturn(run func(context.Context, *sov1.CheckOrderAffiliationRequest, ...grpc.CallOption) (*sov1.CheckOrderAffiliationResponse, error)) *SOServiceClient_CheckOrderAffiliation_Call {
	_c.Call.Return(run)
	return _c
}

// CreateSaleOrder provides a mock function with given fields: ctx, req, opts
func (_m *SOServiceClient) CreateSaleOrder(ctx context.Context, req *sov1.CreateSaleOrderRequest, opts ...grpc.CallOption) (*sov1.CreateSaleOrderResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, req)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.CreateSaleOrderResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.CreateSaleOrderRequest, ...grpc.CallOption) (*sov1.CreateSaleOrderResponse, error)); ok {
		return rf(ctx, req, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.CreateSaleOrderRequest, ...grpc.CallOption) *sov1.CreateSaleOrderResponse); ok {
		r0 = rf(ctx, req, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.CreateSaleOrderResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.CreateSaleOrderRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, req, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// CreateSaleOrder is a helper method to define mock.On call
//   - ctx context.Context
//   - req *sov1.CreateSaleOrderRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) CreateSaleOrder(ctx interface{}, req interface{}, opts ...interface{}) *SOServiceClient_CreateSaleOrder_Call {
	return &SOServiceClient_CreateSaleOrder_Call{Call: _e.mock.On("CreateSaleOrder",
		append([]interface{}{ctx, req}, opts...)...)}
}

func (_c *SOServiceClient_CreateSaleOrder_Call) Run(run func(ctx context.Context, req *sov1.CreateSaleOrderRequest, opts ...grpc.CallOption)) *SOServiceClient_CreateSaleOrder_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.CreateSaleOrderRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_CreateSaleOrder_Call) Return(_a0 *sov1.CreateSaleOrderResponse, _a1 error) *SOServiceClient_CreateSaleOrder_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_CreateSaleOrder_Call) RunAndReturn(run func(context.Context, *sov1.CreateSaleOrderRequest, ...grpc.CallOption) (*sov1.CreateSaleOrderResponse, error)) *SOServiceClient_CreateSaleOrder_Call {
	_c.Call.Return(run)
	return _c
}

// GetAsnData provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) GetAsnData(ctx context.Context, re *sov1.GetAsnDataRequest, opts ...grpc.CallOption) (*sov1.GetAsnDataResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.GetAsnDataResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetAsnDataRequest, ...grpc.CallOption) (*sov1.GetAsnDataResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetAsnDataRequest, ...grpc.CallOption) *sov1.GetAsnDataResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.GetAsnDataResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.GetAsnDataRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetAsnData is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.GetAsnDataRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) GetAsnData(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_GetAsnData_Call {
	return &SOServiceClient_GetAsnData_Call{Call: _e.mock.On("GetAsnData",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_GetAsnData_Call) Run(run func(ctx context.Context, re *sov1.GetAsnDataRequest, opts ...grpc.CallOption)) *SOServiceClient_GetAsnData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.GetAsnDataRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_GetAsnData_Call) Return(_a0 *sov1.GetAsnDataResponse, _a1 error) *SOServiceClient_GetAsnData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_GetAsnData_Call) RunAndReturn(run func(context.Context, *sov1.GetAsnDataRequest, ...grpc.CallOption) (*sov1.GetAsnDataResponse, error)) *SOServiceClient_GetAsnData_Call {
	_c.Call.Return(run)
	return _c
}

// GetInvoices provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) GetInvoices(ctx context.Context, re *sov1.GetInvoicesRequest, opts ...grpc.CallOption) (*sov1.GetInvoicesResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.GetInvoicesResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetInvoicesRequest, ...grpc.CallOption) (*sov1.GetInvoicesResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetInvoicesRequest, ...grpc.CallOption) *sov1.GetInvoicesResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.GetInvoicesResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.GetInvoicesRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetInvoices is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.GetInvoicesRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) GetInvoices(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_GetInvoices_Call {
	return &SOServiceClient_GetInvoices_Call{Call: _e.mock.On("GetInvoices",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_GetInvoices_Call) Run(run func(ctx context.Context, re *sov1.GetInvoicesRequest, opts ...grpc.CallOption)) *SOServiceClient_GetInvoices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.GetInvoicesRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_GetInvoices_Call) Return(_a0 *sov1.GetInvoicesResponse, _a1 error) *SOServiceClient_GetInvoices_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_GetInvoices_Call) RunAndReturn(run func(context.Context, *sov1.GetInvoicesRequest, ...grpc.CallOption) (*sov1.GetInvoicesResponse, error)) *SOServiceClient_GetInvoices_Call {
	_c.Call.Return(run)
	return _c
}

// GetNewReference provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) GetNewReference(ctx context.Context, re *sov1.GetNewReferenceRequest, opts ...grpc.CallOption) (*sov1.GetNewReferenceResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.GetNewReferenceResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetNewReferenceRequest, ...grpc.CallOption) (*sov1.GetNewReferenceResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetNewReferenceRequest, ...grpc.CallOption) *sov1.GetNewReferenceResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.GetNewReferenceResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.GetNewReferenceRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetNewReference is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.GetNewReferenceRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) GetNewReference(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_GetNewReference_Call {
	return &SOServiceClient_GetNewReference_Call{Call: _e.mock.On("GetNewReference",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_GetNewReference_Call) Run(run func(ctx context.Context, re *sov1.GetNewReferenceRequest, opts ...grpc.CallOption)) *SOServiceClient_GetNewReference_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.GetNewReferenceRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_GetNewReference_Call) Return(_a0 *sov1.GetNewReferenceResponse, _a1 error) *SOServiceClient_GetNewReference_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_GetNewReference_Call) RunAndReturn(run func(context.Context, *sov1.GetNewReferenceRequest, ...grpc.CallOption) (*sov1.GetNewReferenceResponse, error)) *SOServiceClient_GetNewReference_Call {
	_c.Call.Return(run)
	return _c
}

// GetShipments provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) GetShipments(ctx context.Context, re *sov1.GetShipmentsRequest, opts ...grpc.CallOption) (*sov1.GetShipmentsResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.GetShipmentsResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetShipmentsRequest, ...grpc.CallOption) (*sov1.GetShipmentsResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetShipmentsRequest, ...grpc.CallOption) *sov1.GetShipmentsResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.GetShipmentsResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.GetShipmentsRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetShipments is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.GetShipmentsRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) GetShipments(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_GetShipments_Call {
	return &SOServiceClient_GetShipments_Call{Call: _e.mock.On("GetShipments",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_GetShipments_Call) Run(run func(ctx context.Context, re *sov1.GetShipmentsRequest, opts ...grpc.CallOption)) *SOServiceClient_GetShipments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.GetShipmentsRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_GetShipments_Call) Return(_a0 *sov1.GetShipmentsResponse, _a1 error) *SOServiceClient_GetShipments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_GetShipments_Call) RunAndReturn(run func(context.Context, *sov1.GetShipmentsRequest, ...grpc.CallOption) (*sov1.GetShipmentsResponse, error)) *SOServiceClient_GetShipments_Call {
	_c.Call.Return(run)
	return _c
}

// GetSummary provides a mock function with given fields: ctx, in, opts
func (_m *SOServiceClient) GetSummary(ctx context.Context, in *sov1.GetSummaryRequest, opts ...grpc.CallOption) (*sov1.GetSummaryResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, in)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.GetSummaryResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetSummaryRequest, ...grpc.CallOption) (*sov1.GetSummaryResponse, error)); ok {
		return rf(ctx, in, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.GetSummaryRequest, ...grpc.CallOption) *sov1.GetSummaryResponse); ok {
		r0 = rf(ctx, in, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.GetSummaryResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.GetSummaryRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, in, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// GetSummary is a helper method to define mock.On call
//   - ctx context.Context
//   - in *sov1.GetSummaryRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) GetSummary(ctx interface{}, in interface{}, opts ...interface{}) *SOServiceClient_GetSummary_Call {
	return &SOServiceClient_GetSummary_Call{Call: _e.mock.On("GetSummary",
		append([]interface{}{ctx, in}, opts...)...)}
}

func (_c *SOServiceClient_GetSummary_Call) Run(run func(ctx context.Context, in *sov1.GetSummaryRequest, opts ...grpc.CallOption)) *SOServiceClient_GetSummary_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.GetSummaryRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_GetSummary_Call) Return(_a0 *sov1.GetSummaryResponse, _a1 error) *SOServiceClient_GetSummary_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_GetSummary_Call) RunAndReturn(run func(context.Context, *sov1.GetSummaryRequest, ...grpc.CallOption) (*sov1.GetSummaryResponse, error)) *SOServiceClient_GetSummary_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveDocument provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) RemoveDocument(ctx context.Context, re *sov1.RemoveDocumentRequest, opts ...grpc.CallOption) (*sov1.RemoveDocumentResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.RemoveDocumentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.RemoveDocumentRequest, ...grpc.CallOption) (*sov1.RemoveDocumentResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.RemoveDocumentRequest, ...grpc.CallOption) *sov1.RemoveDocumentResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.RemoveDocumentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.RemoveDocumentRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// RemoveDocument is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.RemoveDocumentRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) RemoveDocument(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_RemoveDocument_Call {
	return &SOServiceClient_RemoveDocument_Call{Call: _e.mock.On("RemoveDocument",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_RemoveDocument_Call) Run(run func(ctx context.Context, re *sov1.RemoveDocumentRequest, opts ...grpc.CallOption)) *SOServiceClient_RemoveDocument_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.RemoveDocumentRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_RemoveDocument_Call) Return(_a0 *sov1.RemoveDocumentResponse, _a1 error) *SOServiceClient_RemoveDocument_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_RemoveDocument_Call) RunAndReturn(run func(context.Context, *sov1.RemoveDocumentRequest, ...grpc.CallOption) (*sov1.RemoveDocumentResponse, error)) *SOServiceClient_RemoveDocument_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateNote provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) UpdateNote(ctx context.Context, re *sov1.UpdateNoteRequest, opts ...grpc.CallOption) (*sov1.UpdateNoteResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.UpdateNoteResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.UpdateNoteRequest, ...grpc.CallOption) (*sov1.UpdateNoteResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.UpdateNoteRequest, ...grpc.CallOption) *sov1.UpdateNoteResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.UpdateNoteResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.UpdateNoteRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateNote is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.UpdateNoteRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) UpdateNote(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_UpdateNote_Call {
	return &SOServiceClient_UpdateNote_Call{Call: _e.mock.On("UpdateNote",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_UpdateNote_Call) Run(run func(ctx context.Context, re *sov1.UpdateNoteRequest, opts ...grpc.CallOption)) *SOServiceClient_UpdateNote_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.UpdateNoteRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_UpdateNote_Call) Return(_a0 *sov1.UpdateNoteResponse, _a1 error) *SOServiceClient_UpdateNote_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_UpdateNote_Call) RunAndReturn(run func(context.Context, *sov1.UpdateNoteRequest, ...grpc.CallOption) (*sov1.UpdateNoteResponse, error)) *SOServiceClient_UpdateNote_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateShipment provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) UpdateShipment(ctx context.Context, re *sov1.UpdateShipmentRequest, opts ...grpc.CallOption) (*sov1.UpdateShipmentResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.UpdateShipmentResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.UpdateShipmentRequest, ...grpc.CallOption) (*sov1.UpdateShipmentResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.UpdateShipmentRequest, ...grpc.CallOption) *sov1.UpdateShipmentResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.UpdateShipmentResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.UpdateShipmentRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateShipment is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.UpdateShipmentRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) UpdateShipment(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_UpdateShipment_Call {
	return &SOServiceClient_UpdateShipment_Call{Call: _e.mock.On("UpdateShipment",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_UpdateShipment_Call) Run(run func(ctx context.Context, re *sov1.UpdateShipmentRequest, opts ...grpc.CallOption)) *SOServiceClient_UpdateShipment_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.UpdateShipmentRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_UpdateShipment_Call) Return(_a0 *sov1.UpdateShipmentResponse, _a1 error) *SOServiceClient_UpdateShipment_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_UpdateShipment_Call) RunAndReturn(run func(context.Context, *sov1.UpdateShipmentRequest, ...grpc.CallOption) (*sov1.UpdateShipmentResponse, error)) *SOServiceClient_UpdateShipment_Call {
	_c.Call.Return(run)
	return _c
}

// UpdateStatus provides a mock function with given fields: ctx, re, opts
func (_m *SOServiceClient) UpdateStatus(ctx context.Context, re *sov1.UpdateStatusRequest, opts ...grpc.CallOption) (*sov1.UpdateStatusResponse, error) {
	_va := make([]interface{}, len(opts))
	for _i := range opts {
		_va[_i] = opts[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, ctx, re)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *sov1.UpdateStatusResponse
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.UpdateStatusRequest, ...grpc.CallOption) (*sov1.UpdateStatusResponse, error)); ok {
		return rf(ctx, re, opts...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *sov1.UpdateStatusRequest, ...grpc.CallOption) *sov1.UpdateStatusResponse); ok {
		r0 = rf(ctx, re, opts...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*sov1.UpdateStatusResponse)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *sov1.UpdateStatusRequest, ...grpc.CallOption) error); ok {
		r1 = rf(ctx, re, opts...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// UpdateStatus is a helper method to define mock.On call
//   - ctx context.Context
//   - re *sov1.UpdateStatusRequest
//   - opts ...grpc.CallOption
func (_e *SOServiceClient_Expecter) UpdateStatus(ctx interface{}, re interface{}, opts ...interface{}) *SOServiceClient_UpdateStatus_Call {
	return &SOServiceClient_UpdateStatus_Call{Call: _e.mock.On("UpdateStatus",
		append([]interface{}{ctx, re}, opts...)...)}
}

func (_c *SOServiceClient_UpdateStatus_Call) Run(run func(ctx context.Context, re *sov1.UpdateStatusRequest, opts ...grpc.CallOption)) *SOServiceClient_UpdateStatus_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]grpc.CallOption, len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(grpc.CallOption)
			}
		}
		run(args[0].(context.Context), args[1].(*sov1.UpdateStatusRequest), variadicArgs...)
	})
	return _c
}

func (_c *SOServiceClient_UpdateStatus_Call) Return(_a0 *sov1.UpdateStatusResponse, _a1 error) *SOServiceClient_UpdateStatus_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *SOServiceClient_UpdateStatus_Call) RunAndReturn(run func(context.Context, *sov1.UpdateStatusRequest, ...grpc.CallOption) (*sov1.UpdateStatusResponse, error)) *SOServiceClient_UpdateStatus_Call {
	_c.Call.Return(run)
	return _c
}

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

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

	return mock
}