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"
	Analysis_Log_FullMethodName                   = "/analysis.Analysis/Log"
	Analysis_Overview_FullMethodName              = "/analysis.Analysis/Overview"
	Analysis_User_FullMethodName                  = "/analysis.Analysis/User"
	Analysis_UserDetail_FullMethodName            = "/analysis.Analysis/UserDetail"
	Analysis_UserFacepp_FullMethodName            = "/analysis.Analysis/UserFacepp"
	Analysis_UserMode_FullMethodName              = "/analysis.Analysis/UserMode"
	Analysis_UserLog_FullMethodName               = "/analysis.Analysis/UserLog"
	Analysis_Banners_FullMethodName               = "/analysis.Analysis/Banners"
	Analysis_QrcodeShare_FullMethodName           = "/analysis.Analysis/QrcodeShare"
	Analysis_GraphDetail_FullMethodName           = "/analysis.Analysis/GraphDetail"
	Analysis_FaceppMaps_FullMethodName            = "/analysis.Analysis/FaceppMaps"
	Analysis_FaceppMapBoxes_FullMethodName        = "/analysis.Analysis/FaceppMapBoxes"
	Analysis_FaceppMapBoxDelete_FullMethodName    = "/analysis.Analysis/FaceppMapBoxDelete"
	Analysis_ImagesDate_FullMethodName            = "/analysis.Analysis/ImagesDate"
	Analysis_ImagesList_FullMethodName            = "/analysis.Analysis/ImagesList"
	Analysis_ModeImage_FullMethodName             = "/analysis.Analysis/ModeImage"
	Analysis_DeviceUpdate_FullMethodName          = "/analysis.Analysis/DeviceUpdate"
)

// 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)
	Log(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error)
	Overview(ctx context.Context, in *OverviewReq, opts ...grpc.CallOption) (*Response, error)
	User(ctx context.Context, in *UserReq, opts ...grpc.CallOption) (*Response, error)
	UserDetail(ctx context.Context, in *UserDetailReq, opts ...grpc.CallOption) (*Response, error)
	UserFacepp(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error)
	UserMode(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
	UserLog(ctx context.Context, in *LogReq, opts ...grpc.CallOption) (*Response, error)
	Banners(ctx context.Context, in *EmptyReq, opts ...grpc.CallOption) (*Response, error)
	QrcodeShare(ctx context.Context, in *QrcodeShareReq, opts ...grpc.CallOption) (*Response, error)
	GraphDetail(ctx context.Context, in *GraphDetailReq, opts ...grpc.CallOption) (*Response, error)
	FaceppMaps(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error)
	FaceppMapBoxes(ctx context.Context, in *FaceppMapBoxesReq, opts ...grpc.CallOption) (*Response, error)
	FaceppMapBoxDelete(ctx context.Context, in *IdReq, opts ...grpc.CallOption) (*Response, error)
	ImagesDate(ctx context.Context, in *ImagesDateReq, opts ...grpc.CallOption) (*Response, error)
	ImagesList(ctx context.Context, in *ImagesListReq, opts ...grpc.CallOption) (*Response, error)
	ModeImage(ctx context.Context, in *TaskIdReq, opts ...grpc.CallOption) (*Response, error)
	DeviceUpdate(ctx context.Context, in *DeviceUpdateReq, 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (c *analysisClient) DeviceUpdate(ctx context.Context, in *DeviceUpdateReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, Analysis_DeviceUpdate_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)
	Log(context.Context, *LogReq) (*Response, error)
	Overview(context.Context, *OverviewReq) (*Response, error)
	User(context.Context, *UserReq) (*Response, error)
	UserDetail(context.Context, *UserDetailReq) (*Response, error)
	UserFacepp(context.Context, *TaskIdReq) (*Response, error)
	UserMode(context.Context, *EmptyReq) (*Response, error)
	UserLog(context.Context, *LogReq) (*Response, error)
	Banners(context.Context, *EmptyReq) (*Response, error)
	QrcodeShare(context.Context, *QrcodeShareReq) (*Response, error)
	GraphDetail(context.Context, *GraphDetailReq) (*Response, error)
	FaceppMaps(context.Context, *TaskIdReq) (*Response, error)
	FaceppMapBoxes(context.Context, *FaceppMapBoxesReq) (*Response, error)
	FaceppMapBoxDelete(context.Context, *IdReq) (*Response, error)
	ImagesDate(context.Context, *ImagesDateReq) (*Response, error)
	ImagesList(context.Context, *ImagesListReq) (*Response, error)
	ModeImage(context.Context, *TaskIdReq) (*Response, error)
	DeviceUpdate(context.Context, *DeviceUpdateReq) (*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) Log(context.Context, *LogReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method Log not implemented")
}
func (UnimplementedAnalysisServer) Overview(context.Context, *OverviewReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method Overview not implemented")
}
func (UnimplementedAnalysisServer) User(context.Context, *UserReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method User not implemented")
}
func (UnimplementedAnalysisServer) UserDetail(context.Context, *UserDetailReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserDetail not implemented")
}
func (UnimplementedAnalysisServer) UserFacepp(context.Context, *TaskIdReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserFacepp not implemented")
}
func (UnimplementedAnalysisServer) UserMode(context.Context, *EmptyReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserMode not implemented")
}
func (UnimplementedAnalysisServer) UserLog(context.Context, *LogReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserLog not implemented")
}
func (UnimplementedAnalysisServer) Banners(context.Context, *EmptyReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method Banners not implemented")
}
func (UnimplementedAnalysisServer) QrcodeShare(context.Context, *QrcodeShareReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method QrcodeShare not implemented")
}
func (UnimplementedAnalysisServer) GraphDetail(context.Context, *GraphDetailReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method GraphDetail not implemented")
}
func (UnimplementedAnalysisServer) FaceppMaps(context.Context, *TaskIdReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method FaceppMaps not implemented")
}
func (UnimplementedAnalysisServer) FaceppMapBoxes(context.Context, *FaceppMapBoxesReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method FaceppMapBoxes not implemented")
}
func (UnimplementedAnalysisServer) FaceppMapBoxDelete(context.Context, *IdReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method FaceppMapBoxDelete not implemented")
}
func (UnimplementedAnalysisServer) ImagesDate(context.Context, *ImagesDateReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method ImagesDate not implemented")
}
func (UnimplementedAnalysisServer) ImagesList(context.Context, *ImagesListReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method ImagesList not implemented")
}
func (UnimplementedAnalysisServer) ModeImage(context.Context, *TaskIdReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method ModeImage not implemented")
}
func (UnimplementedAnalysisServer) DeviceUpdate(context.Context, *DeviceUpdateReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method DeviceUpdate 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func _Analysis_DeviceUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeviceUpdateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisServer).DeviceUpdate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Analysis_DeviceUpdate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisServer).DeviceUpdate(ctx, req.(*DeviceUpdateReq))
	}
	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,
		},
		{
			MethodName: "Log",
			Handler:    _Analysis_Log_Handler,
		},
		{
			MethodName: "Overview",
			Handler:    _Analysis_Overview_Handler,
		},
		{
			MethodName: "User",
			Handler:    _Analysis_User_Handler,
		},
		{
			MethodName: "UserDetail",
			Handler:    _Analysis_UserDetail_Handler,
		},
		{
			MethodName: "UserFacepp",
			Handler:    _Analysis_UserFacepp_Handler,
		},
		{
			MethodName: "UserMode",
			Handler:    _Analysis_UserMode_Handler,
		},
		{
			MethodName: "UserLog",
			Handler:    _Analysis_UserLog_Handler,
		},
		{
			MethodName: "Banners",
			Handler:    _Analysis_Banners_Handler,
		},
		{
			MethodName: "QrcodeShare",
			Handler:    _Analysis_QrcodeShare_Handler,
		},
		{
			MethodName: "GraphDetail",
			Handler:    _Analysis_GraphDetail_Handler,
		},
		{
			MethodName: "FaceppMaps",
			Handler:    _Analysis_FaceppMaps_Handler,
		},
		{
			MethodName: "FaceppMapBoxes",
			Handler:    _Analysis_FaceppMapBoxes_Handler,
		},
		{
			MethodName: "FaceppMapBoxDelete",
			Handler:    _Analysis_FaceppMapBoxDelete_Handler,
		},
		{
			MethodName: "ImagesDate",
			Handler:    _Analysis_ImagesDate_Handler,
		},
		{
			MethodName: "ImagesList",
			Handler:    _Analysis_ImagesList_Handler,
		},
		{
			MethodName: "ModeImage",
			Handler:    _Analysis_ModeImage_Handler,
		},
		{
			MethodName: "DeviceUpdate",
			Handler:    _Analysis_DeviceUpdate_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"
	AnalysisUser_UserLogDelete_FullMethodName  = "/analysis.AnalysisUser/UserLogDelete"
	AnalysisUser_UserStatus_FullMethodName     = "/analysis.AnalysisUser/UserStatus"
)

// 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)
	UserLogDelete(ctx context.Context, in *UserLogDeleteReq, opts ...grpc.CallOption) (*Response, error)
	UserStatus(ctx context.Context, in *UserStatusReq, 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
}

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

func (c *analysisUserClient) UserStatus(ctx context.Context, in *UserStatusReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisUser_UserStatus_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)
	UserLogDelete(context.Context, *UserLogDeleteReq) (*Response, error)
	UserStatus(context.Context, *UserStatusReq) (*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) UserLogDelete(context.Context, *UserLogDeleteReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserLogDelete not implemented")
}
func (UnimplementedAnalysisUserServer) UserStatus(context.Context, *UserStatusReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserStatus 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)
}

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

func _AnalysisUser_UserStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UserStatusReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisUserServer).UserStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisUser_UserStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisUserServer).UserStatus(ctx, req.(*UserStatusReq))
	}
	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,
		},
		{
			MethodName: "UserLogDelete",
			Handler:    _AnalysisUser_UserLogDelete_Handler,
		},
		{
			MethodName: "UserStatus",
			Handler:    _AnalysisUser_UserStatus_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_FaceLogin_FullMethodName   = "/analysis.AnalysisDevice/FaceLogin"
	AnalysisDevice_Policy_FullMethodName      = "/analysis.AnalysisDevice/Policy"
	AnalysisDevice_Display_FullMethodName     = "/analysis.AnalysisDevice/Display"
	AnalysisDevice_OssCallback_FullMethodName = "/analysis.AnalysisDevice/OssCallback"
	AnalysisDevice_PyCallback_FullMethodName  = "/analysis.AnalysisDevice/PyCallback"
)

// 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 {
	FaceLogin(ctx context.Context, in *FaceLoginReq, opts ...grpc.CallOption) (*Response, error)
	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)
	PyCallback(ctx context.Context, in *PyCallbackReq, opts ...grpc.CallOption) (*Response, error)
}

type analysisDeviceClient struct {
	cc grpc.ClientConnInterface
}

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

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

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
}

func (c *analysisDeviceClient) PyCallback(ctx context.Context, in *PyCallbackReq, opts ...grpc.CallOption) (*Response, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Response)
	err := c.cc.Invoke(ctx, AnalysisDevice_PyCallback_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 {
	FaceLogin(context.Context, *FaceLoginReq) (*Response, error)
	Policy(context.Context, *DevicePolicyReq) (*Response, error)
	Display(context.Context, *DeviceDisplayReq) (*Response, error)
	OssCallback(context.Context, *OssCallbackReq) (*OssCallbackResp, error)
	PyCallback(context.Context, *PyCallbackReq) (*Response, 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) FaceLogin(context.Context, *FaceLoginReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method FaceLogin not implemented")
}
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) PyCallback(context.Context, *PyCallbackReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method PyCallback 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_FaceLogin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FaceLoginReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisDeviceServer).FaceLogin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisDevice_FaceLogin_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisDeviceServer).FaceLogin(ctx, req.(*FaceLoginReq))
	}
	return interceptor(ctx, in, info, handler)
}

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)
}

func _AnalysisDevice_PyCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PyCallbackReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisDeviceServer).PyCallback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisDevice_PyCallback_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisDeviceServer).PyCallback(ctx, req.(*PyCallbackReq))
	}
	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: "FaceLogin",
			Handler:    _AnalysisDevice_FaceLogin_Handler,
		},
		{
			MethodName: "Policy",
			Handler:    _AnalysisDevice_Policy_Handler,
		},
		{
			MethodName: "Display",
			Handler:    _AnalysisDevice_Display_Handler,
		},
		{
			MethodName: "OssCallback",
			Handler:    _AnalysisDevice_OssCallback_Handler,
		},
		{
			MethodName: "PyCallback",
			Handler:    _AnalysisDevice_PyCallback_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "analysis/analysis.proto",
}

const (
	AnalysisAdmin_UserList_FullMethodName    = "/analysis.AnalysisAdmin/UserList"
	AnalysisAdmin_UserArchive_FullMethodName = "/analysis.AnalysisAdmin/UserArchive"
	AnalysisAdmin_UserDetail_FullMethodName  = "/analysis.AnalysisAdmin/UserDetail"
)

// AnalysisAdminClient is the client API for AnalysisAdmin 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 AnalysisAdminClient interface {
	UserList(ctx context.Context, in *AdminUserListReq, opts ...grpc.CallOption) (*Response, error)
	UserArchive(ctx context.Context, in *AdminUserArchiveReq, opts ...grpc.CallOption) (*Response, error)
	UserDetail(ctx context.Context, in *AdminUserDetailReq, opts ...grpc.CallOption) (*Response, error)
}

type analysisAdminClient struct {
	cc grpc.ClientConnInterface
}

func NewAnalysisAdminClient(cc grpc.ClientConnInterface) AnalysisAdminClient {
	return &analysisAdminClient{cc}
}

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

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

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

// AnalysisAdminServer is the server API for AnalysisAdmin service.
// All implementations must embed UnimplementedAnalysisAdminServer
// for forward compatibility.
type AnalysisAdminServer interface {
	UserList(context.Context, *AdminUserListReq) (*Response, error)
	UserArchive(context.Context, *AdminUserArchiveReq) (*Response, error)
	UserDetail(context.Context, *AdminUserDetailReq) (*Response, error)
	mustEmbedUnimplementedAnalysisAdminServer()
}

// UnimplementedAnalysisAdminServer 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 UnimplementedAnalysisAdminServer struct{}

func (UnimplementedAnalysisAdminServer) UserList(context.Context, *AdminUserListReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserList not implemented")
}
func (UnimplementedAnalysisAdminServer) UserArchive(context.Context, *AdminUserArchiveReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserArchive not implemented")
}
func (UnimplementedAnalysisAdminServer) UserDetail(context.Context, *AdminUserDetailReq) (*Response, error) {
	return nil, status.Error(codes.Unimplemented, "method UserDetail not implemented")
}
func (UnimplementedAnalysisAdminServer) mustEmbedUnimplementedAnalysisAdminServer() {}
func (UnimplementedAnalysisAdminServer) testEmbeddedByValue()                       {}

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

func RegisterAnalysisAdminServer(s grpc.ServiceRegistrar, srv AnalysisAdminServer) {
	// If the following call panics, it indicates UnimplementedAnalysisAdminServer 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(&AnalysisAdmin_ServiceDesc, srv)
}

func _AnalysisAdmin_UserList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminUserListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisAdminServer).UserList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisAdmin_UserList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisAdminServer).UserList(ctx, req.(*AdminUserListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisAdmin_UserArchive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminUserArchiveReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisAdminServer).UserArchive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisAdmin_UserArchive_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisAdminServer).UserArchive(ctx, req.(*AdminUserArchiveReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _AnalysisAdmin_UserDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdminUserDetailReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AnalysisAdminServer).UserDetail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AnalysisAdmin_UserDetail_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AnalysisAdminServer).UserDetail(ctx, req.(*AdminUserDetailReq))
	}
	return interceptor(ctx, in, info, handler)
}

// AnalysisAdmin_ServiceDesc is the grpc.ServiceDesc for AnalysisAdmin service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AnalysisAdmin_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "analysis.AnalysisAdmin",
	HandlerType: (*AnalysisAdminServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "UserList",
			Handler:    _AnalysisAdmin_UserList_Handler,
		},
		{
			MethodName: "UserArchive",
			Handler:    _AnalysisAdmin_UserArchive_Handler,
		},
		{
			MethodName: "UserDetail",
			Handler:    _AnalysisAdmin_UserDetail_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "analysis/analysis.proto",
}