lone-services/rpc/analysis/pb/analysis_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.2
// - protoc             v3.19.4
// source: analysis/analysis.proto

package analysis

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	Analysis_InternalCreateUser_FullMethodName    = "/analysis.Analysis/InternalCreateUser"
	Analysis_InternalSetRegistered_FullMethodName = "/analysis.Analysis/InternalSetRegistered"
	Analysis_AgreementInfo_FullMethodName         = "/analysis.Analysis/AgreementInfo"
	Analysis_Switch_FullMethodName                = "/analysis.Analysis/Switch"
	Analysis_QrcodeInfo_FullMethodName            = "/analysis.Analysis/QrcodeInfo"
)

// AnalysisClient is the client API for Analysis service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AnalysisClient interface {
	InternalCreateUser(ctx context.Context, in *InternalCreateUserReq, opts ...grpc.CallOption) (*InternalCreateUserData, error)
	InternalSetRegistered(ctx context.Context, in *InternalSetRegisteredReq, opts ...grpc.CallOption) (*InternalSetRegisteredData, error)
	AgreementInfo(ctx context.Context, in *AgreementInfoReq, opts ...grpc.CallOption) (*Response, error)
	Switch(ctx context.Context, in *SwitchReq, opts ...grpc.CallOption) (*Response, error)
	QrcodeInfo(ctx context.Context, in *QrcodeInfoReq, opts ...grpc.CallOption) (*Response, error)
}

type analysisClient struct {
	cc grpc.ClientConnInterface
}

func NewAnalysisClient(cc grpc.ClientConnInterface) AnalysisClient {
	return &analysisClient{cc}
}

func (c *analysisClient) InternalCreateUser(ctx context.Context, in *InternalCreateUserReq, opts ...grpc.CallOption) (*InternalCreateUserData, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InternalCreateUserData)
	err := c.cc.Invoke(ctx, Analysis_InternalCreateUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisClient) InternalSetRegistered(ctx context.Context, in *InternalSetRegisteredReq, opts ...grpc.CallOption) (*InternalSetRegisteredData, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(InternalSetRegisteredData)
	err := c.cc.Invoke(ctx, Analysis_InternalSetRegistered_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisClient) AgreementInfo(ctx context.Context, in *AgreementInfoReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, Analysis_AgreementInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisClient) Switch(ctx context.Context, in *SwitchReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, Analysis_Switch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisClient) QrcodeInfo(ctx context.Context, in *QrcodeInfoReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, Analysis_QrcodeInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AnalysisServer is the server API for Analysis service.
// All implementations must embed UnimplementedAnalysisServer
// for forward compatibility.
type AnalysisServer interface {
	InternalCreateUser(context.Context, *InternalCreateUserReq) (*InternalCreateUserData, error)
	InternalSetRegistered(context.Context, *InternalSetRegisteredReq) (*InternalSetRegisteredData, error)
	AgreementInfo(context.Context, *AgreementInfoReq) (*Response, error)
	Switch(context.Context, *SwitchReq) (*Response, error)
	QrcodeInfo(context.Context, *QrcodeInfoReq) (*Response, error)
	mustEmbedUnimplementedAnalysisServer()
}

// UnimplementedAnalysisServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedAnalysisServer struct{}

func (UnimplementedAnalysisServer) InternalCreateUser(context.Context, *InternalCreateUserReq) (*InternalCreateUserData, error) {
	return nil, status.Error(codes.Unimplemented, "method InternalCreateUser not implemented")
}
func (UnimplementedAnalysisServer) InternalSetRegistered(context.Context, *InternalSetRegisteredReq) (*InternalSetRegisteredData, error) {
	return nil, status.Error(codes.Unimplemented, "method InternalSetRegistered not implemented")
}
func (UnimplementedAnalysisServer) AgreementInfo(context.Context, *AgreementInfoReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method AgreementInfo not implemented")
}
func (UnimplementedAnalysisServer) Switch(context.Context, *SwitchReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method Switch not implemented")
}
func (UnimplementedAnalysisServer) QrcodeInfo(context.Context, *QrcodeInfoReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method QrcodeInfo not implemented")
}
func (UnimplementedAnalysisServer) mustEmbedUnimplementedAnalysisServer() {}
func (UnimplementedAnalysisServer) testEmbeddedByValue()                  {}

// UnsafeAnalysisServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AnalysisServer will
// result in compilation errors.
type UnsafeAnalysisServer interface {
	mustEmbedUnimplementedAnalysisServer()
}

func RegisterAnalysisServer(s grpc.ServiceRegistrar, srv AnalysisServer) {
	// If the following call panics, it indicates UnimplementedAnalysisServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&Analysis_ServiceDesc, srv)
}

func _Analysis_InternalCreateUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InternalCreateUserReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServer).InternalCreateUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Analysis_InternalCreateUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServer).InternalCreateUser(ctx, req.(*InternalCreateUserReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Analysis_InternalSetRegistered_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(InternalSetRegisteredReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServer).InternalSetRegistered(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Analysis_InternalSetRegistered_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServer).InternalSetRegistered(ctx, req.(*InternalSetRegisteredReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Analysis_AgreementInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AgreementInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServer).AgreementInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Analysis_AgreementInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServer).AgreementInfo(ctx, req.(*AgreementInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Analysis_Switch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SwitchReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServer).Switch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Analysis_Switch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServer).Switch(ctx, req.(*SwitchReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Analysis_QrcodeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QrcodeInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServer).QrcodeInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Analysis_QrcodeInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServer).QrcodeInfo(ctx, req.(*QrcodeInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

// Analysis_ServiceDesc is the grpc.ServiceDesc for Analysis service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Analysis_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "analysis.Analysis",
	HandlerType: (*AnalysisServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "InternalCreateUser",
			Handler:    _Analysis_InternalCreateUser_Handler,
		},
		{
			MethodName: "InternalSetRegistered",
			Handler:    _Analysis_InternalSetRegistered_Handler,
		},
		{
			MethodName: "AgreementInfo",
			Handler:    _Analysis_AgreementInfo_Handler,
		},
		{
			MethodName: "Switch",
			Handler:    _Analysis_Switch_Handler,
		},
		{
			MethodName: "QrcodeInfo",
			Handler:    _Analysis_QrcodeInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "analysis/analysis.proto",
}

const (
	AnalysisUser_FaceBind_FullMethodName       = "/analysis.AnalysisUser/FaceBind"
	AnalysisUser_UserImprove_FullMethodName    = "/analysis.AnalysisUser/UserImprove"
	AnalysisUser_UserDelete_FullMethodName     = "/analysis.AnalysisUser/UserDelete"
	AnalysisUser_UserAuth_FullMethodName       = "/analysis.AnalysisUser/UserAuth"
	AnalysisUser_UserAuthList_FullMethodName   = "/analysis.AnalysisUser/UserAuthList"
	AnalysisUser_UserAuthDelete_FullMethodName = "/analysis.AnalysisUser/UserAuthDelete"
	AnalysisUser_UserAuthUpdate_FullMethodName = "/analysis.AnalysisUser/UserAuthUpdate"
	AnalysisUser_DeviceBind_FullMethodName     = "/analysis.AnalysisUser/DeviceBind"
	AnalysisUser_DeviceInfo_FullMethodName     = "/analysis.AnalysisUser/DeviceInfo"
)

// AnalysisUserClient is the client API for AnalysisUser service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AnalysisUserClient interface {
	FaceBind(ctx context.Context, in *FaceBindReq, opts ...grpc.CallOption) (*Response, error)
	UserImprove(ctx context.Context, in *UserImproveReq, opts ...grpc.CallOption) (*Response, error)
	UserDelete(ctx context.Context, in *UserDeleteReq, opts ...grpc.CallOption) (*Response, error)
	UserAuth(ctx context.Context, in *UserAuthReq, opts ...grpc.CallOption) (*Response, error)
	UserAuthList(ctx context.Context, in *UserAuthListReq, opts ...grpc.CallOption) (*Response, error)
	UserAuthDelete(ctx context.Context, in *UserAuthDeleteReq, opts ...grpc.CallOption) (*Response, error)
	UserAuthUpdate(ctx context.Context, in *UserAuthUpdateReq, opts ...grpc.CallOption) (*Response, error)
	DeviceBind(ctx context.Context, in *DeviceBindReq, opts ...grpc.CallOption) (*Response, error)
	DeviceInfo(ctx context.Context, in *DeviceInfoReq, opts ...grpc.CallOption) (*Response, error)
}

type analysisUserClient struct {
	cc grpc.ClientConnInterface
}

func NewAnalysisUserClient(cc grpc.ClientConnInterface) AnalysisUserClient {
	return &analysisUserClient{cc}
}

func (c *analysisUserClient) FaceBind(ctx context.Context, in *FaceBindReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_FaceBind_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) UserImprove(ctx context.Context, in *UserImproveReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserImprove_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) UserDelete(ctx context.Context, in *UserDeleteReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserDelete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) UserAuth(ctx context.Context, in *UserAuthReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserAuth_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) UserAuthList(ctx context.Context, in *UserAuthListReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserAuthList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) UserAuthDelete(ctx context.Context, in *UserAuthDeleteReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserAuthDelete_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) UserAuthUpdate(ctx context.Context, in *UserAuthUpdateReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserAuthUpdate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) DeviceBind(ctx context.Context, in *DeviceBindReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_DeviceBind_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisUserClient) DeviceInfo(ctx context.Context, in *DeviceInfoReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_DeviceInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AnalysisUserServer is the server API for AnalysisUser service.
// All implementations must embed UnimplementedAnalysisUserServer
// for forward compatibility.
type AnalysisUserServer interface {
	FaceBind(context.Context, *FaceBindReq) (*Response, error)
	UserImprove(context.Context, *UserImproveReq) (*Response, error)
	UserDelete(context.Context, *UserDeleteReq) (*Response, error)
	UserAuth(context.Context, *UserAuthReq) (*Response, error)
	UserAuthList(context.Context, *UserAuthListReq) (*Response, error)
	UserAuthDelete(context.Context, *UserAuthDeleteReq) (*Response, error)
	UserAuthUpdate(context.Context, *UserAuthUpdateReq) (*Response, error)
	DeviceBind(context.Context, *DeviceBindReq) (*Response, error)
	DeviceInfo(context.Context, *DeviceInfoReq) (*Response, error)
	mustEmbedUnimplementedAnalysisUserServer()
}

// UnimplementedAnalysisUserServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedAnalysisUserServer struct{}

func (UnimplementedAnalysisUserServer) FaceBind(context.Context, *FaceBindReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method FaceBind not implemented")
}
func (UnimplementedAnalysisUserServer) UserImprove(context.Context, *UserImproveReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserImprove not implemented")
}
func (UnimplementedAnalysisUserServer) UserDelete(context.Context, *UserDeleteReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserDelete not implemented")
}
func (UnimplementedAnalysisUserServer) UserAuth(context.Context, *UserAuthReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserAuth not implemented")
}
func (UnimplementedAnalysisUserServer) UserAuthList(context.Context, *UserAuthListReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserAuthList not implemented")
}
func (UnimplementedAnalysisUserServer) UserAuthDelete(context.Context, *UserAuthDeleteReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserAuthDelete not implemented")
}
func (UnimplementedAnalysisUserServer) UserAuthUpdate(context.Context, *UserAuthUpdateReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserAuthUpdate not implemented")
}
func (UnimplementedAnalysisUserServer) DeviceBind(context.Context, *DeviceBindReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method DeviceBind not implemented")
}
func (UnimplementedAnalysisUserServer) DeviceInfo(context.Context, *DeviceInfoReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method DeviceInfo not implemented")
}
func (UnimplementedAnalysisUserServer) mustEmbedUnimplementedAnalysisUserServer() {}
func (UnimplementedAnalysisUserServer) testEmbeddedByValue()                      {}

// UnsafeAnalysisUserServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AnalysisUserServer will
// result in compilation errors.
type UnsafeAnalysisUserServer interface {
	mustEmbedUnimplementedAnalysisUserServer()
}

func RegisterAnalysisUserServer(s grpc.ServiceRegistrar, srv AnalysisUserServer) {
	// If the following call panics, it indicates UnimplementedAnalysisUserServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&AnalysisUser_ServiceDesc, srv)
}

func _AnalysisUser_FaceBind_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FaceBindReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).FaceBind(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_FaceBind_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).FaceBind(ctx, req.(*FaceBindReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_UserImprove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserImproveReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserImprove(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserImprove_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserImprove(ctx, req.(*UserImproveReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_UserDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserDeleteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserDelete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserDelete(ctx, req.(*UserDeleteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_UserAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserAuthReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserAuth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserAuth_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserAuth(ctx, req.(*UserAuthReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_UserAuthList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserAuthListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserAuthList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserAuthList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserAuthList(ctx, req.(*UserAuthListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_UserAuthDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserAuthDeleteReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserAuthDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserAuthDelete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserAuthDelete(ctx, req.(*UserAuthDeleteReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_UserAuthUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserAuthUpdateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserAuthUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserAuthUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserAuthUpdate(ctx, req.(*UserAuthUpdateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_DeviceBind_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceBindReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).DeviceBind(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_DeviceBind_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).DeviceBind(ctx, req.(*DeviceBindReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisUser_DeviceInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).DeviceInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_DeviceInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).DeviceInfo(ctx, req.(*DeviceInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

// AnalysisUser_ServiceDesc is the grpc.ServiceDesc for AnalysisUser service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AnalysisUser_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "analysis.AnalysisUser",
	HandlerType: (*AnalysisUserServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "FaceBind",
			Handler:    _AnalysisUser_FaceBind_Handler,
		},
		{
			MethodName: "UserImprove",
			Handler:    _AnalysisUser_UserImprove_Handler,
		},
		{
			MethodName: "UserDelete",
			Handler:    _AnalysisUser_UserDelete_Handler,
		},
		{
			MethodName: "UserAuth",
			Handler:    _AnalysisUser_UserAuth_Handler,
		},
		{
			MethodName: "UserAuthList",
			Handler:    _AnalysisUser_UserAuthList_Handler,
		},
		{
			MethodName: "UserAuthDelete",
			Handler:    _AnalysisUser_UserAuthDelete_Handler,
		},
		{
			MethodName: "UserAuthUpdate",
			Handler:    _AnalysisUser_UserAuthUpdate_Handler,
		},
		{
			MethodName: "DeviceBind",
			Handler:    _AnalysisUser_DeviceBind_Handler,
		},
		{
			MethodName: "DeviceInfo",
			Handler:    _AnalysisUser_DeviceInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "analysis/analysis.proto",
}

const (
	AnalysisStore_StoreAuth_FullMethodName       = "/analysis.AnalysisStore/StoreAuth"
	AnalysisStore_StoreAuthQrcode_FullMethodName = "/analysis.AnalysisStore/StoreAuthQrcode"
	AnalysisStore_StoreInfo_FullMethodName       = "/analysis.AnalysisStore/StoreInfo"
	AnalysisStore_StoreUserList_FullMethodName   = "/analysis.AnalysisStore/StoreUserList"
	AnalysisStore_StoreUserUpdate_FullMethodName = "/analysis.AnalysisStore/StoreUserUpdate"
	AnalysisStore_StoreUserInfo_FullMethodName   = "/analysis.AnalysisStore/StoreUserInfo"
)

// AnalysisStoreClient is the client API for AnalysisStore service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AnalysisStoreClient interface {
	StoreAuth(ctx context.Context, in *StoreAuthReq, opts ...grpc.CallOption) (*Response, error)
	StoreAuthQrcode(ctx context.Context, in *StoreAuthQrcodeReq, opts ...grpc.CallOption) (*Response, error)
	StoreInfo(ctx context.Context, in *StoreInfoReq, opts ...grpc.CallOption) (*Response, error)
	StoreUserList(ctx context.Context, in *StoreUserListReq, opts ...grpc.CallOption) (*Response, error)
	StoreUserUpdate(ctx context.Context, in *StoreUserUpdateReq, opts ...grpc.CallOption) (*Response, error)
	StoreUserInfo(ctx context.Context, in *StoreUserInfoReq, opts ...grpc.CallOption) (*Response, error)
}

type analysisStoreClient struct {
	cc grpc.ClientConnInterface
}

func NewAnalysisStoreClient(cc grpc.ClientConnInterface) AnalysisStoreClient {
	return &analysisStoreClient{cc}
}

func (c *analysisStoreClient) StoreAuth(ctx context.Context, in *StoreAuthReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisStore_StoreAuth_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisStoreClient) StoreAuthQrcode(ctx context.Context, in *StoreAuthQrcodeReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisStore_StoreAuthQrcode_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisStoreClient) StoreInfo(ctx context.Context, in *StoreInfoReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisStore_StoreInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisStoreClient) StoreUserList(ctx context.Context, in *StoreUserListReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisStore_StoreUserList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisStoreClient) StoreUserUpdate(ctx context.Context, in *StoreUserUpdateReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisStore_StoreUserUpdate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisStoreClient) StoreUserInfo(ctx context.Context, in *StoreUserInfoReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisStore_StoreUserInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AnalysisStoreServer is the server API for AnalysisStore service.
// All implementations must embed UnimplementedAnalysisStoreServer
// for forward compatibility.
type AnalysisStoreServer interface {
	StoreAuth(context.Context, *StoreAuthReq) (*Response, error)
	StoreAuthQrcode(context.Context, *StoreAuthQrcodeReq) (*Response, error)
	StoreInfo(context.Context, *StoreInfoReq) (*Response, error)
	StoreUserList(context.Context, *StoreUserListReq) (*Response, error)
	StoreUserUpdate(context.Context, *StoreUserUpdateReq) (*Response, error)
	StoreUserInfo(context.Context, *StoreUserInfoReq) (*Response, error)
	mustEmbedUnimplementedAnalysisStoreServer()
}

// UnimplementedAnalysisStoreServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedAnalysisStoreServer struct{}

func (UnimplementedAnalysisStoreServer) StoreAuth(context.Context, *StoreAuthReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method StoreAuth not implemented")
}
func (UnimplementedAnalysisStoreServer) StoreAuthQrcode(context.Context, *StoreAuthQrcodeReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method StoreAuthQrcode not implemented")
}
func (UnimplementedAnalysisStoreServer) StoreInfo(context.Context, *StoreInfoReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method StoreInfo not implemented")
}
func (UnimplementedAnalysisStoreServer) StoreUserList(context.Context, *StoreUserListReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method StoreUserList not implemented")
}
func (UnimplementedAnalysisStoreServer) StoreUserUpdate(context.Context, *StoreUserUpdateReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method StoreUserUpdate not implemented")
}
func (UnimplementedAnalysisStoreServer) StoreUserInfo(context.Context, *StoreUserInfoReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method StoreUserInfo not implemented")
}
func (UnimplementedAnalysisStoreServer) mustEmbedUnimplementedAnalysisStoreServer() {}
func (UnimplementedAnalysisStoreServer) testEmbeddedByValue()                       {}

// UnsafeAnalysisStoreServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AnalysisStoreServer will
// result in compilation errors.
type UnsafeAnalysisStoreServer interface {
	mustEmbedUnimplementedAnalysisStoreServer()
}

func RegisterAnalysisStoreServer(s grpc.ServiceRegistrar, srv AnalysisStoreServer) {
	// If the following call panics, it indicates UnimplementedAnalysisStoreServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&AnalysisStore_ServiceDesc, srv)
}

func _AnalysisStore_StoreAuth_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreAuthReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisStoreServer).StoreAuth(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisStore_StoreAuth_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisStoreServer).StoreAuth(ctx, req.(*StoreAuthReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisStore_StoreAuthQrcode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreAuthQrcodeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisStoreServer).StoreAuthQrcode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisStore_StoreAuthQrcode_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisStoreServer).StoreAuthQrcode(ctx, req.(*StoreAuthQrcodeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisStore_StoreInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisStoreServer).StoreInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisStore_StoreInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisStoreServer).StoreInfo(ctx, req.(*StoreInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisStore_StoreUserList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreUserListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisStoreServer).StoreUserList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisStore_StoreUserList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisStoreServer).StoreUserList(ctx, req.(*StoreUserListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisStore_StoreUserUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreUserUpdateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisStoreServer).StoreUserUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisStore_StoreUserUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisStoreServer).StoreUserUpdate(ctx, req.(*StoreUserUpdateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisStore_StoreUserInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreUserInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisStoreServer).StoreUserInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisStore_StoreUserInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisStoreServer).StoreUserInfo(ctx, req.(*StoreUserInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

// AnalysisStore_ServiceDesc is the grpc.ServiceDesc for AnalysisStore service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AnalysisStore_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "analysis.AnalysisStore",
	HandlerType: (*AnalysisStoreServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "StoreAuth",
			Handler:    _AnalysisStore_StoreAuth_Handler,
		},
		{
			MethodName: "StoreAuthQrcode",
			Handler:    _AnalysisStore_StoreAuthQrcode_Handler,
		},
		{
			MethodName: "StoreInfo",
			Handler:    _AnalysisStore_StoreInfo_Handler,
		},
		{
			MethodName: "StoreUserList",
			Handler:    _AnalysisStore_StoreUserList_Handler,
		},
		{
			MethodName: "StoreUserUpdate",
			Handler:    _AnalysisStore_StoreUserUpdate_Handler,
		},
		{
			MethodName: "StoreUserInfo",
			Handler:    _AnalysisStore_StoreUserInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "analysis/analysis.proto",
}

const (
	AnalysisDevice_Policy_FullMethodName      = "/analysis.AnalysisDevice/Policy"
	AnalysisDevice_Display_FullMethodName     = "/analysis.AnalysisDevice/Display"
	AnalysisDevice_OssCallback_FullMethodName = "/analysis.AnalysisDevice/OssCallback"
)

// AnalysisDeviceClient is the client API for AnalysisDevice service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type AnalysisDeviceClient interface {
	Policy(ctx context.Context, in *DevicePolicyReq, opts ...grpc.CallOption) (*Response, error)
	Display(ctx context.Context, in *DeviceDisplayReq, opts ...grpc.CallOption) (*Response, error)
	OssCallback(ctx context.Context, in *OssCallbackReq, opts ...grpc.CallOption) (*OssCallbackResp, error)
}

type analysisDeviceClient struct {
	cc grpc.ClientConnInterface
}

func NewAnalysisDeviceClient(cc grpc.ClientConnInterface) AnalysisDeviceClient {
	return &analysisDeviceClient{cc}
}

func (c *analysisDeviceClient) Policy(ctx context.Context, in *DevicePolicyReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisDevice_Policy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisDeviceClient) Display(ctx context.Context, in *DeviceDisplayReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisDevice_Display_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *analysisDeviceClient) OssCallback(ctx context.Context, in *OssCallbackReq, opts ...grpc.CallOption) (*OssCallbackResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OssCallbackResp)
	err := c.cc.Invoke(ctx, AnalysisDevice_OssCallback_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AnalysisDeviceServer is the server API for AnalysisDevice service.
// All implementations must embed UnimplementedAnalysisDeviceServer
// for forward compatibility.
type AnalysisDeviceServer interface {
	Policy(context.Context, *DevicePolicyReq) (*Response, error)
	Display(context.Context, *DeviceDisplayReq) (*Response, error)
	OssCallback(context.Context, *OssCallbackReq) (*OssCallbackResp, error)
	mustEmbedUnimplementedAnalysisDeviceServer()
}

// UnimplementedAnalysisDeviceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedAnalysisDeviceServer struct{}

func (UnimplementedAnalysisDeviceServer) Policy(context.Context, *DevicePolicyReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method Policy not implemented")
}
func (UnimplementedAnalysisDeviceServer) Display(context.Context, *DeviceDisplayReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method Display not implemented")
}
func (UnimplementedAnalysisDeviceServer) OssCallback(context.Context, *OssCallbackReq) (*OssCallbackResp, error) {
	return nil, status.Error(codes.Unimplemented, "method OssCallback not implemented")
}
func (UnimplementedAnalysisDeviceServer) mustEmbedUnimplementedAnalysisDeviceServer() {}
func (UnimplementedAnalysisDeviceServer) testEmbeddedByValue()                        {}

// UnsafeAnalysisDeviceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to AnalysisDeviceServer will
// result in compilation errors.
type UnsafeAnalysisDeviceServer interface {
	mustEmbedUnimplementedAnalysisDeviceServer()
}

func RegisterAnalysisDeviceServer(s grpc.ServiceRegistrar, srv AnalysisDeviceServer) {
	// If the following call panics, it indicates UnimplementedAnalysisDeviceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&AnalysisDevice_ServiceDesc, srv)
}

func _AnalysisDevice_Policy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DevicePolicyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisDeviceServer).Policy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisDevice_Policy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisDeviceServer).Policy(ctx, req.(*DevicePolicyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisDevice_Display_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceDisplayReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisDeviceServer).Display(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisDevice_Display_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisDeviceServer).Display(ctx, req.(*DeviceDisplayReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisDevice_OssCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OssCallbackReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisDeviceServer).OssCallback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisDevice_OssCallback_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisDeviceServer).OssCallback(ctx, req.(*OssCallbackReq))
	}
	return interceptor(ctx, in, info, handler)
}

// AnalysisDevice_ServiceDesc is the grpc.ServiceDesc for AnalysisDevice service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AnalysisDevice_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "analysis.AnalysisDevice",
	HandlerType: (*AnalysisDeviceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Policy",
			Handler:    _AnalysisDevice_Policy_Handler,
		},
		{
			MethodName: "Display",
			Handler:    _AnalysisDevice_Display_Handler,
		},
		{
			MethodName: "OssCallback",
			Handler:    _AnalysisDevice_OssCallback_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "analysis/analysis.proto",
}