// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.2
// - protoc             v4.25.3
// source: proto/activity/v1/activity.proto

package activityv1

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 (
	ActivityService_PingActivity_FullMethodName      = "/hyapp.activity.v1.ActivityService/PingActivity"
	ActivityService_GetActivityStatus_FullMethodName = "/hyapp.activity.v1.ActivityService/GetActivityStatus"
)

// ActivityServiceClient is the client API for ActivityService 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.
//
// ActivityService 只暴露同步查询，不把事件消费伪装成 RPC。
type ActivityServiceClient interface {
	PingActivity(ctx context.Context, in *PingActivityRequest, opts ...grpc.CallOption) (*PingActivityResponse, error)
	GetActivityStatus(ctx context.Context, in *GetActivityStatusRequest, opts ...grpc.CallOption) (*GetActivityStatusResponse, error)
}

type activityServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewActivityServiceClient(cc grpc.ClientConnInterface) ActivityServiceClient {
	return &activityServiceClient{cc}
}

func (c *activityServiceClient) PingActivity(ctx context.Context, in *PingActivityRequest, opts ...grpc.CallOption) (*PingActivityResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PingActivityResponse)
	err := c.cc.Invoke(ctx, ActivityService_PingActivity_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityServiceClient) GetActivityStatus(ctx context.Context, in *GetActivityStatusRequest, opts ...grpc.CallOption) (*GetActivityStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetActivityStatusResponse)
	err := c.cc.Invoke(ctx, ActivityService_GetActivityStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ActivityServiceServer is the server API for ActivityService service.
// All implementations must embed UnimplementedActivityServiceServer
// for forward compatibility.
//
// ActivityService 只暴露同步查询，不把事件消费伪装成 RPC。
type ActivityServiceServer interface {
	PingActivity(context.Context, *PingActivityRequest) (*PingActivityResponse, error)
	GetActivityStatus(context.Context, *GetActivityStatusRequest) (*GetActivityStatusResponse, error)
	mustEmbedUnimplementedActivityServiceServer()
}

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

func (UnimplementedActivityServiceServer) PingActivity(context.Context, *PingActivityRequest) (*PingActivityResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method PingActivity not implemented")
}
func (UnimplementedActivityServiceServer) GetActivityStatus(context.Context, *GetActivityStatusRequest) (*GetActivityStatusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetActivityStatus not implemented")
}
func (UnimplementedActivityServiceServer) mustEmbedUnimplementedActivityServiceServer() {}
func (UnimplementedActivityServiceServer) testEmbeddedByValue()                         {}

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

func RegisterActivityServiceServer(s grpc.ServiceRegistrar, srv ActivityServiceServer) {
	// If the following call panics, it indicates UnimplementedActivityServiceServer 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(&ActivityService_ServiceDesc, srv)
}

func _ActivityService_PingActivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingActivityRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityServiceServer).PingActivity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityService_PingActivity_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityServiceServer).PingActivity(ctx, req.(*PingActivityRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityService_GetActivityStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetActivityStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityServiceServer).GetActivityStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityService_GetActivityStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityServiceServer).GetActivityStatus(ctx, req.(*GetActivityStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ActivityService_ServiceDesc is the grpc.ServiceDesc for ActivityService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ActivityService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.ActivityService",
	HandlerType: (*ActivityServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PingActivity",
			Handler:    _ActivityService_PingActivity_Handler,
		},
		{
			MethodName: "GetActivityStatus",
			Handler:    _ActivityService_GetActivityStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	MessageInboxService_ListMessageTabs_FullMethodName      = "/hyapp.activity.v1.MessageInboxService/ListMessageTabs"
	MessageInboxService_ListInboxMessages_FullMethodName    = "/hyapp.activity.v1.MessageInboxService/ListInboxMessages"
	MessageInboxService_MarkInboxMessageRead_FullMethodName = "/hyapp.activity.v1.MessageInboxService/MarkInboxMessageRead"
	MessageInboxService_MarkInboxSectionRead_FullMethodName = "/hyapp.activity.v1.MessageInboxService/MarkInboxSectionRead"
	MessageInboxService_DeleteInboxMessage_FullMethodName   = "/hyapp.activity.v1.MessageInboxService/DeleteInboxMessage"
	MessageInboxService_CreateInboxMessage_FullMethodName   = "/hyapp.activity.v1.MessageInboxService/CreateInboxMessage"
	MessageInboxService_CreateFanoutJob_FullMethodName      = "/hyapp.activity.v1.MessageInboxService/CreateFanoutJob"
)

// MessageInboxServiceClient is the client API for MessageInboxService 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.
//
// MessageInboxService 拥有 App system/activity 个人 inbox 事实。
type MessageInboxServiceClient interface {
	ListMessageTabs(ctx context.Context, in *ListMessageTabsRequest, opts ...grpc.CallOption) (*ListMessageTabsResponse, error)
	ListInboxMessages(ctx context.Context, in *ListInboxMessagesRequest, opts ...grpc.CallOption) (*ListInboxMessagesResponse, error)
	MarkInboxMessageRead(ctx context.Context, in *MarkInboxMessageReadRequest, opts ...grpc.CallOption) (*MarkInboxMessageReadResponse, error)
	MarkInboxSectionRead(ctx context.Context, in *MarkInboxSectionReadRequest, opts ...grpc.CallOption) (*MarkInboxSectionReadResponse, error)
	DeleteInboxMessage(ctx context.Context, in *DeleteInboxMessageRequest, opts ...grpc.CallOption) (*DeleteInboxMessageResponse, error)
	CreateInboxMessage(ctx context.Context, in *CreateInboxMessageRequest, opts ...grpc.CallOption) (*CreateInboxMessageResponse, error)
	CreateFanoutJob(ctx context.Context, in *CreateFanoutJobRequest, opts ...grpc.CallOption) (*CreateFanoutJobResponse, error)
}

type messageInboxServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewMessageInboxServiceClient(cc grpc.ClientConnInterface) MessageInboxServiceClient {
	return &messageInboxServiceClient{cc}
}

func (c *messageInboxServiceClient) ListMessageTabs(ctx context.Context, in *ListMessageTabsRequest, opts ...grpc.CallOption) (*ListMessageTabsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListMessageTabsResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_ListMessageTabs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageInboxServiceClient) ListInboxMessages(ctx context.Context, in *ListInboxMessagesRequest, opts ...grpc.CallOption) (*ListInboxMessagesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListInboxMessagesResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_ListInboxMessages_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageInboxServiceClient) MarkInboxMessageRead(ctx context.Context, in *MarkInboxMessageReadRequest, opts ...grpc.CallOption) (*MarkInboxMessageReadResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MarkInboxMessageReadResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_MarkInboxMessageRead_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageInboxServiceClient) MarkInboxSectionRead(ctx context.Context, in *MarkInboxSectionReadRequest, opts ...grpc.CallOption) (*MarkInboxSectionReadResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MarkInboxSectionReadResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_MarkInboxSectionRead_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageInboxServiceClient) DeleteInboxMessage(ctx context.Context, in *DeleteInboxMessageRequest, opts ...grpc.CallOption) (*DeleteInboxMessageResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteInboxMessageResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_DeleteInboxMessage_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageInboxServiceClient) CreateInboxMessage(ctx context.Context, in *CreateInboxMessageRequest, opts ...grpc.CallOption) (*CreateInboxMessageResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateInboxMessageResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_CreateInboxMessage_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageInboxServiceClient) CreateFanoutJob(ctx context.Context, in *CreateFanoutJobRequest, opts ...grpc.CallOption) (*CreateFanoutJobResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateFanoutJobResponse)
	err := c.cc.Invoke(ctx, MessageInboxService_CreateFanoutJob_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MessageInboxServiceServer is the server API for MessageInboxService service.
// All implementations must embed UnimplementedMessageInboxServiceServer
// for forward compatibility.
//
// MessageInboxService 拥有 App system/activity 个人 inbox 事实。
type MessageInboxServiceServer interface {
	ListMessageTabs(context.Context, *ListMessageTabsRequest) (*ListMessageTabsResponse, error)
	ListInboxMessages(context.Context, *ListInboxMessagesRequest) (*ListInboxMessagesResponse, error)
	MarkInboxMessageRead(context.Context, *MarkInboxMessageReadRequest) (*MarkInboxMessageReadResponse, error)
	MarkInboxSectionRead(context.Context, *MarkInboxSectionReadRequest) (*MarkInboxSectionReadResponse, error)
	DeleteInboxMessage(context.Context, *DeleteInboxMessageRequest) (*DeleteInboxMessageResponse, error)
	CreateInboxMessage(context.Context, *CreateInboxMessageRequest) (*CreateInboxMessageResponse, error)
	CreateFanoutJob(context.Context, *CreateFanoutJobRequest) (*CreateFanoutJobResponse, error)
	mustEmbedUnimplementedMessageInboxServiceServer()
}

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

func (UnimplementedMessageInboxServiceServer) ListMessageTabs(context.Context, *ListMessageTabsRequest) (*ListMessageTabsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListMessageTabs not implemented")
}
func (UnimplementedMessageInboxServiceServer) ListInboxMessages(context.Context, *ListInboxMessagesRequest) (*ListInboxMessagesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListInboxMessages not implemented")
}
func (UnimplementedMessageInboxServiceServer) MarkInboxMessageRead(context.Context, *MarkInboxMessageReadRequest) (*MarkInboxMessageReadResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method MarkInboxMessageRead not implemented")
}
func (UnimplementedMessageInboxServiceServer) MarkInboxSectionRead(context.Context, *MarkInboxSectionReadRequest) (*MarkInboxSectionReadResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method MarkInboxSectionRead not implemented")
}
func (UnimplementedMessageInboxServiceServer) DeleteInboxMessage(context.Context, *DeleteInboxMessageRequest) (*DeleteInboxMessageResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteInboxMessage not implemented")
}
func (UnimplementedMessageInboxServiceServer) CreateInboxMessage(context.Context, *CreateInboxMessageRequest) (*CreateInboxMessageResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateInboxMessage not implemented")
}
func (UnimplementedMessageInboxServiceServer) CreateFanoutJob(context.Context, *CreateFanoutJobRequest) (*CreateFanoutJobResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateFanoutJob not implemented")
}
func (UnimplementedMessageInboxServiceServer) mustEmbedUnimplementedMessageInboxServiceServer() {}
func (UnimplementedMessageInboxServiceServer) testEmbeddedByValue()                             {}

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

func RegisterMessageInboxServiceServer(s grpc.ServiceRegistrar, srv MessageInboxServiceServer) {
	// If the following call panics, it indicates UnimplementedMessageInboxServiceServer 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(&MessageInboxService_ServiceDesc, srv)
}

func _MessageInboxService_ListMessageTabs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListMessageTabsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).ListMessageTabs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_ListMessageTabs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).ListMessageTabs(ctx, req.(*ListMessageTabsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageInboxService_ListInboxMessages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListInboxMessagesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).ListInboxMessages(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_ListInboxMessages_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).ListInboxMessages(ctx, req.(*ListInboxMessagesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageInboxService_MarkInboxMessageRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MarkInboxMessageReadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).MarkInboxMessageRead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_MarkInboxMessageRead_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).MarkInboxMessageRead(ctx, req.(*MarkInboxMessageReadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageInboxService_MarkInboxSectionRead_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MarkInboxSectionReadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).MarkInboxSectionRead(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_MarkInboxSectionRead_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).MarkInboxSectionRead(ctx, req.(*MarkInboxSectionReadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageInboxService_DeleteInboxMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteInboxMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).DeleteInboxMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_DeleteInboxMessage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).DeleteInboxMessage(ctx, req.(*DeleteInboxMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageInboxService_CreateInboxMessage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateInboxMessageRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).CreateInboxMessage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_CreateInboxMessage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).CreateInboxMessage(ctx, req.(*CreateInboxMessageRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageInboxService_CreateFanoutJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateFanoutJobRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageInboxServiceServer).CreateFanoutJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageInboxService_CreateFanoutJob_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageInboxServiceServer).CreateFanoutJob(ctx, req.(*CreateFanoutJobRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// MessageInboxService_ServiceDesc is the grpc.ServiceDesc for MessageInboxService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var MessageInboxService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.MessageInboxService",
	HandlerType: (*MessageInboxServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListMessageTabs",
			Handler:    _MessageInboxService_ListMessageTabs_Handler,
		},
		{
			MethodName: "ListInboxMessages",
			Handler:    _MessageInboxService_ListInboxMessages_Handler,
		},
		{
			MethodName: "MarkInboxMessageRead",
			Handler:    _MessageInboxService_MarkInboxMessageRead_Handler,
		},
		{
			MethodName: "MarkInboxSectionRead",
			Handler:    _MessageInboxService_MarkInboxSectionRead_Handler,
		},
		{
			MethodName: "DeleteInboxMessage",
			Handler:    _MessageInboxService_DeleteInboxMessage_Handler,
		},
		{
			MethodName: "CreateInboxMessage",
			Handler:    _MessageInboxService_CreateInboxMessage_Handler,
		},
		{
			MethodName: "CreateFanoutJob",
			Handler:    _MessageInboxService_CreateFanoutJob_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	ActivityCronService_ProcessMessageFanoutBatch_FullMethodName     = "/hyapp.activity.v1.ActivityCronService/ProcessMessageFanoutBatch"
	ActivityCronService_ProcessLevelRewardBatch_FullMethodName       = "/hyapp.activity.v1.ActivityCronService/ProcessLevelRewardBatch"
	ActivityCronService_ProcessAchievementRewardBatch_FullMethodName = "/hyapp.activity.v1.ActivityCronService/ProcessAchievementRewardBatch"
)

// ActivityCronServiceClient is the client API for ActivityCronService 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.
//
// ActivityCronService 只给 cron-service 调用，活动和消息状态仍由 activity-service owner 修改。
type ActivityCronServiceClient interface {
	ProcessMessageFanoutBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
	ProcessLevelRewardBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
	ProcessAchievementRewardBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
}

type activityCronServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewActivityCronServiceClient(cc grpc.ClientConnInterface) ActivityCronServiceClient {
	return &activityCronServiceClient{cc}
}

func (c *activityCronServiceClient) ProcessMessageFanoutBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CronBatchResponse)
	err := c.cc.Invoke(ctx, ActivityCronService_ProcessMessageFanoutBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityCronServiceClient) ProcessLevelRewardBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CronBatchResponse)
	err := c.cc.Invoke(ctx, ActivityCronService_ProcessLevelRewardBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityCronServiceClient) ProcessAchievementRewardBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CronBatchResponse)
	err := c.cc.Invoke(ctx, ActivityCronService_ProcessAchievementRewardBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ActivityCronServiceServer is the server API for ActivityCronService service.
// All implementations must embed UnimplementedActivityCronServiceServer
// for forward compatibility.
//
// ActivityCronService 只给 cron-service 调用，活动和消息状态仍由 activity-service owner 修改。
type ActivityCronServiceServer interface {
	ProcessMessageFanoutBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	ProcessLevelRewardBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	ProcessAchievementRewardBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	mustEmbedUnimplementedActivityCronServiceServer()
}

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

func (UnimplementedActivityCronServiceServer) ProcessMessageFanoutBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ProcessMessageFanoutBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessLevelRewardBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ProcessLevelRewardBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessAchievementRewardBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ProcessAchievementRewardBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) mustEmbedUnimplementedActivityCronServiceServer() {}
func (UnimplementedActivityCronServiceServer) testEmbeddedByValue()                             {}

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

func RegisterActivityCronServiceServer(s grpc.ServiceRegistrar, srv ActivityCronServiceServer) {
	// If the following call panics, it indicates UnimplementedActivityCronServiceServer 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(&ActivityCronService_ServiceDesc, srv)
}

func _ActivityCronService_ProcessMessageFanoutBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CronBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityCronServiceServer).ProcessMessageFanoutBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessMessageFanoutBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessMessageFanoutBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityCronService_ProcessLevelRewardBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CronBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityCronServiceServer).ProcessLevelRewardBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessLevelRewardBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessLevelRewardBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityCronService_ProcessAchievementRewardBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CronBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ActivityCronServiceServer).ProcessAchievementRewardBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessAchievementRewardBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessAchievementRewardBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ActivityCronService_ServiceDesc is the grpc.ServiceDesc for ActivityCronService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ActivityCronService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.ActivityCronService",
	HandlerType: (*ActivityCronServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ProcessMessageFanoutBatch",
			Handler:    _ActivityCronService_ProcessMessageFanoutBatch_Handler,
		},
		{
			MethodName: "ProcessLevelRewardBatch",
			Handler:    _ActivityCronService_ProcessLevelRewardBatch_Handler,
		},
		{
			MethodName: "ProcessAchievementRewardBatch",
			Handler:    _ActivityCronService_ProcessAchievementRewardBatch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	TaskService_ListUserTasks_FullMethodName    = "/hyapp.activity.v1.TaskService/ListUserTasks"
	TaskService_ClaimTaskReward_FullMethodName  = "/hyapp.activity.v1.TaskService/ClaimTaskReward"
	TaskService_ConsumeTaskEvent_FullMethodName = "/hyapp.activity.v1.TaskService/ConsumeTaskEvent"
)

// TaskServiceClient is the client API for TaskService 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.
//
// TaskService 拥有 App 任务查询、事件进度消费和领奖状态。
type TaskServiceClient interface {
	ListUserTasks(ctx context.Context, in *ListUserTasksRequest, opts ...grpc.CallOption) (*ListUserTasksResponse, error)
	ClaimTaskReward(ctx context.Context, in *ClaimTaskRewardRequest, opts ...grpc.CallOption) (*ClaimTaskRewardResponse, error)
	ConsumeTaskEvent(ctx context.Context, in *ConsumeTaskEventRequest, opts ...grpc.CallOption) (*ConsumeTaskEventResponse, error)
}

type taskServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewTaskServiceClient(cc grpc.ClientConnInterface) TaskServiceClient {
	return &taskServiceClient{cc}
}

func (c *taskServiceClient) ListUserTasks(ctx context.Context, in *ListUserTasksRequest, opts ...grpc.CallOption) (*ListUserTasksResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListUserTasksResponse)
	err := c.cc.Invoke(ctx, TaskService_ListUserTasks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) ClaimTaskReward(ctx context.Context, in *ClaimTaskRewardRequest, opts ...grpc.CallOption) (*ClaimTaskRewardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClaimTaskRewardResponse)
	err := c.cc.Invoke(ctx, TaskService_ClaimTaskReward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *taskServiceClient) ConsumeTaskEvent(ctx context.Context, in *ConsumeTaskEventRequest, opts ...grpc.CallOption) (*ConsumeTaskEventResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConsumeTaskEventResponse)
	err := c.cc.Invoke(ctx, TaskService_ConsumeTaskEvent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// TaskServiceServer is the server API for TaskService service.
// All implementations must embed UnimplementedTaskServiceServer
// for forward compatibility.
//
// TaskService 拥有 App 任务查询、事件进度消费和领奖状态。
type TaskServiceServer interface {
	ListUserTasks(context.Context, *ListUserTasksRequest) (*ListUserTasksResponse, error)
	ClaimTaskReward(context.Context, *ClaimTaskRewardRequest) (*ClaimTaskRewardResponse, error)
	ConsumeTaskEvent(context.Context, *ConsumeTaskEventRequest) (*ConsumeTaskEventResponse, error)
	mustEmbedUnimplementedTaskServiceServer()
}

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

func (UnimplementedTaskServiceServer) ListUserTasks(context.Context, *ListUserTasksRequest) (*ListUserTasksResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListUserTasks not implemented")
}
func (UnimplementedTaskServiceServer) ClaimTaskReward(context.Context, *ClaimTaskRewardRequest) (*ClaimTaskRewardResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ClaimTaskReward not implemented")
}
func (UnimplementedTaskServiceServer) ConsumeTaskEvent(context.Context, *ConsumeTaskEventRequest) (*ConsumeTaskEventResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ConsumeTaskEvent not implemented")
}
func (UnimplementedTaskServiceServer) mustEmbedUnimplementedTaskServiceServer() {}
func (UnimplementedTaskServiceServer) testEmbeddedByValue()                     {}

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

func RegisterTaskServiceServer(s grpc.ServiceRegistrar, srv TaskServiceServer) {
	// If the following call panics, it indicates UnimplementedTaskServiceServer 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(&TaskService_ServiceDesc, srv)
}

func _TaskService_ListUserTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListUserTasksRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).ListUserTasks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TaskService_ListUserTasks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).ListUserTasks(ctx, req.(*ListUserTasksRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_ClaimTaskReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClaimTaskRewardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).ClaimTaskReward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TaskService_ClaimTaskReward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).ClaimTaskReward(ctx, req.(*ClaimTaskRewardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _TaskService_ConsumeTaskEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumeTaskEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(TaskServiceServer).ConsumeTaskEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: TaskService_ConsumeTaskEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(TaskServiceServer).ConsumeTaskEvent(ctx, req.(*ConsumeTaskEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// TaskService_ServiceDesc is the grpc.ServiceDesc for TaskService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var TaskService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.TaskService",
	HandlerType: (*TaskServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListUserTasks",
			Handler:    _TaskService_ListUserTasks_Handler,
		},
		{
			MethodName: "ClaimTaskReward",
			Handler:    _TaskService_ClaimTaskReward_Handler,
		},
		{
			MethodName: "ConsumeTaskEvent",
			Handler:    _TaskService_ConsumeTaskEvent_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	GrowthLevelService_GetMyLevelOverview_FullMethodName = "/hyapp.activity.v1.GrowthLevelService/GetMyLevelOverview"
	GrowthLevelService_GetLevelTrack_FullMethodName      = "/hyapp.activity.v1.GrowthLevelService/GetLevelTrack"
	GrowthLevelService_ListLevelRewards_FullMethodName   = "/hyapp.activity.v1.GrowthLevelService/ListLevelRewards"
	GrowthLevelService_ConsumeLevelEvent_FullMethodName  = "/hyapp.activity.v1.GrowthLevelService/ConsumeLevelEvent"
)

// GrowthLevelServiceClient is the client API for GrowthLevelService 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.
//
// GrowthLevelService 拥有 App 等级查询和内部等级事件消费。
type GrowthLevelServiceClient interface {
	GetMyLevelOverview(ctx context.Context, in *GetMyLevelOverviewRequest, opts ...grpc.CallOption) (*GetMyLevelOverviewResponse, error)
	GetLevelTrack(ctx context.Context, in *GetLevelTrackRequest, opts ...grpc.CallOption) (*GetLevelTrackResponse, error)
	ListLevelRewards(ctx context.Context, in *ListLevelRewardsRequest, opts ...grpc.CallOption) (*ListLevelRewardsResponse, error)
	ConsumeLevelEvent(ctx context.Context, in *ConsumeLevelEventRequest, opts ...grpc.CallOption) (*ConsumeLevelEventResponse, error)
}

type growthLevelServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGrowthLevelServiceClient(cc grpc.ClientConnInterface) GrowthLevelServiceClient {
	return &growthLevelServiceClient{cc}
}

func (c *growthLevelServiceClient) GetMyLevelOverview(ctx context.Context, in *GetMyLevelOverviewRequest, opts ...grpc.CallOption) (*GetMyLevelOverviewResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetMyLevelOverviewResponse)
	err := c.cc.Invoke(ctx, GrowthLevelService_GetMyLevelOverview_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *growthLevelServiceClient) GetLevelTrack(ctx context.Context, in *GetLevelTrackRequest, opts ...grpc.CallOption) (*GetLevelTrackResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetLevelTrackResponse)
	err := c.cc.Invoke(ctx, GrowthLevelService_GetLevelTrack_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *growthLevelServiceClient) ListLevelRewards(ctx context.Context, in *ListLevelRewardsRequest, opts ...grpc.CallOption) (*ListLevelRewardsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListLevelRewardsResponse)
	err := c.cc.Invoke(ctx, GrowthLevelService_ListLevelRewards_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *growthLevelServiceClient) ConsumeLevelEvent(ctx context.Context, in *ConsumeLevelEventRequest, opts ...grpc.CallOption) (*ConsumeLevelEventResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConsumeLevelEventResponse)
	err := c.cc.Invoke(ctx, GrowthLevelService_ConsumeLevelEvent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GrowthLevelServiceServer is the server API for GrowthLevelService service.
// All implementations must embed UnimplementedGrowthLevelServiceServer
// for forward compatibility.
//
// GrowthLevelService 拥有 App 等级查询和内部等级事件消费。
type GrowthLevelServiceServer interface {
	GetMyLevelOverview(context.Context, *GetMyLevelOverviewRequest) (*GetMyLevelOverviewResponse, error)
	GetLevelTrack(context.Context, *GetLevelTrackRequest) (*GetLevelTrackResponse, error)
	ListLevelRewards(context.Context, *ListLevelRewardsRequest) (*ListLevelRewardsResponse, error)
	ConsumeLevelEvent(context.Context, *ConsumeLevelEventRequest) (*ConsumeLevelEventResponse, error)
	mustEmbedUnimplementedGrowthLevelServiceServer()
}

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

func (UnimplementedGrowthLevelServiceServer) GetMyLevelOverview(context.Context, *GetMyLevelOverviewRequest) (*GetMyLevelOverviewResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetMyLevelOverview not implemented")
}
func (UnimplementedGrowthLevelServiceServer) GetLevelTrack(context.Context, *GetLevelTrackRequest) (*GetLevelTrackResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetLevelTrack not implemented")
}
func (UnimplementedGrowthLevelServiceServer) ListLevelRewards(context.Context, *ListLevelRewardsRequest) (*ListLevelRewardsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListLevelRewards not implemented")
}
func (UnimplementedGrowthLevelServiceServer) ConsumeLevelEvent(context.Context, *ConsumeLevelEventRequest) (*ConsumeLevelEventResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ConsumeLevelEvent not implemented")
}
func (UnimplementedGrowthLevelServiceServer) mustEmbedUnimplementedGrowthLevelServiceServer() {}
func (UnimplementedGrowthLevelServiceServer) testEmbeddedByValue()                            {}

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

func RegisterGrowthLevelServiceServer(s grpc.ServiceRegistrar, srv GrowthLevelServiceServer) {
	// If the following call panics, it indicates UnimplementedGrowthLevelServiceServer 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(&GrowthLevelService_ServiceDesc, srv)
}

func _GrowthLevelService_GetMyLevelOverview_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMyLevelOverviewRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrowthLevelServiceServer).GetMyLevelOverview(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GrowthLevelService_GetMyLevelOverview_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrowthLevelServiceServer).GetMyLevelOverview(ctx, req.(*GetMyLevelOverviewRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrowthLevelService_GetLevelTrack_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLevelTrackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrowthLevelServiceServer).GetLevelTrack(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GrowthLevelService_GetLevelTrack_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrowthLevelServiceServer).GetLevelTrack(ctx, req.(*GetLevelTrackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrowthLevelService_ListLevelRewards_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListLevelRewardsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrowthLevelServiceServer).ListLevelRewards(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GrowthLevelService_ListLevelRewards_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrowthLevelServiceServer).ListLevelRewards(ctx, req.(*ListLevelRewardsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrowthLevelService_ConsumeLevelEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumeLevelEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrowthLevelServiceServer).ConsumeLevelEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GrowthLevelService_ConsumeLevelEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrowthLevelServiceServer).ConsumeLevelEvent(ctx, req.(*ConsumeLevelEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GrowthLevelService_ServiceDesc is the grpc.ServiceDesc for GrowthLevelService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GrowthLevelService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.GrowthLevelService",
	HandlerType: (*GrowthLevelServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetMyLevelOverview",
			Handler:    _GrowthLevelService_GetMyLevelOverview_Handler,
		},
		{
			MethodName: "GetLevelTrack",
			Handler:    _GrowthLevelService_GetLevelTrack_Handler,
		},
		{
			MethodName: "ListLevelRewards",
			Handler:    _GrowthLevelService_ListLevelRewards_Handler,
		},
		{
			MethodName: "ConsumeLevelEvent",
			Handler:    _GrowthLevelService_ConsumeLevelEvent_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AchievementService_ListAchievements_FullMethodName        = "/hyapp.activity.v1.AchievementService/ListAchievements"
	AchievementService_ConsumeAchievementEvent_FullMethodName = "/hyapp.activity.v1.AchievementService/ConsumeAchievementEvent"
	AchievementService_ListMyBadges_FullMethodName            = "/hyapp.activity.v1.AchievementService/ListMyBadges"
	AchievementService_SetBadgeDisplay_FullMethodName         = "/hyapp.activity.v1.AchievementService/SetBadgeDisplay"
)

// AchievementServiceClient is the client API for AchievementService 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.
//
// AchievementService owns App achievement reads, badge display and internal achievement event consumption.
type AchievementServiceClient interface {
	ListAchievements(ctx context.Context, in *ListAchievementsRequest, opts ...grpc.CallOption) (*ListAchievementsResponse, error)
	ConsumeAchievementEvent(ctx context.Context, in *ConsumeAchievementEventRequest, opts ...grpc.CallOption) (*ConsumeAchievementEventResponse, error)
	ListMyBadges(ctx context.Context, in *ListMyBadgesRequest, opts ...grpc.CallOption) (*ListMyBadgesResponse, error)
	SetBadgeDisplay(ctx context.Context, in *SetBadgeDisplayRequest, opts ...grpc.CallOption) (*SetBadgeDisplayResponse, error)
}

type achievementServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAchievementServiceClient(cc grpc.ClientConnInterface) AchievementServiceClient {
	return &achievementServiceClient{cc}
}

func (c *achievementServiceClient) ListAchievements(ctx context.Context, in *ListAchievementsRequest, opts ...grpc.CallOption) (*ListAchievementsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAchievementsResponse)
	err := c.cc.Invoke(ctx, AchievementService_ListAchievements_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *achievementServiceClient) ConsumeAchievementEvent(ctx context.Context, in *ConsumeAchievementEventRequest, opts ...grpc.CallOption) (*ConsumeAchievementEventResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConsumeAchievementEventResponse)
	err := c.cc.Invoke(ctx, AchievementService_ConsumeAchievementEvent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *achievementServiceClient) ListMyBadges(ctx context.Context, in *ListMyBadgesRequest, opts ...grpc.CallOption) (*ListMyBadgesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListMyBadgesResponse)
	err := c.cc.Invoke(ctx, AchievementService_ListMyBadges_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *achievementServiceClient) SetBadgeDisplay(ctx context.Context, in *SetBadgeDisplayRequest, opts ...grpc.CallOption) (*SetBadgeDisplayResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetBadgeDisplayResponse)
	err := c.cc.Invoke(ctx, AchievementService_SetBadgeDisplay_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AchievementServiceServer is the server API for AchievementService service.
// All implementations must embed UnimplementedAchievementServiceServer
// for forward compatibility.
//
// AchievementService owns App achievement reads, badge display and internal achievement event consumption.
type AchievementServiceServer interface {
	ListAchievements(context.Context, *ListAchievementsRequest) (*ListAchievementsResponse, error)
	ConsumeAchievementEvent(context.Context, *ConsumeAchievementEventRequest) (*ConsumeAchievementEventResponse, error)
	ListMyBadges(context.Context, *ListMyBadgesRequest) (*ListMyBadgesResponse, error)
	SetBadgeDisplay(context.Context, *SetBadgeDisplayRequest) (*SetBadgeDisplayResponse, error)
	mustEmbedUnimplementedAchievementServiceServer()
}

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

func (UnimplementedAchievementServiceServer) ListAchievements(context.Context, *ListAchievementsRequest) (*ListAchievementsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListAchievements not implemented")
}
func (UnimplementedAchievementServiceServer) ConsumeAchievementEvent(context.Context, *ConsumeAchievementEventRequest) (*ConsumeAchievementEventResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ConsumeAchievementEvent not implemented")
}
func (UnimplementedAchievementServiceServer) ListMyBadges(context.Context, *ListMyBadgesRequest) (*ListMyBadgesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListMyBadges not implemented")
}
func (UnimplementedAchievementServiceServer) SetBadgeDisplay(context.Context, *SetBadgeDisplayRequest) (*SetBadgeDisplayResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SetBadgeDisplay not implemented")
}
func (UnimplementedAchievementServiceServer) mustEmbedUnimplementedAchievementServiceServer() {}
func (UnimplementedAchievementServiceServer) testEmbeddedByValue()                            {}

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

func RegisterAchievementServiceServer(s grpc.ServiceRegistrar, srv AchievementServiceServer) {
	// If the following call panics, it indicates UnimplementedAchievementServiceServer 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(&AchievementService_ServiceDesc, srv)
}

func _AchievementService_ListAchievements_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAchievementsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AchievementServiceServer).ListAchievements(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AchievementService_ListAchievements_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AchievementServiceServer).ListAchievements(ctx, req.(*ListAchievementsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AchievementService_ConsumeAchievementEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumeAchievementEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AchievementServiceServer).ConsumeAchievementEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AchievementService_ConsumeAchievementEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AchievementServiceServer).ConsumeAchievementEvent(ctx, req.(*ConsumeAchievementEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AchievementService_ListMyBadges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListMyBadgesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AchievementServiceServer).ListMyBadges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AchievementService_ListMyBadges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AchievementServiceServer).ListMyBadges(ctx, req.(*ListMyBadgesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AchievementService_SetBadgeDisplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetBadgeDisplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AchievementServiceServer).SetBadgeDisplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AchievementService_SetBadgeDisplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AchievementServiceServer).SetBadgeDisplay(ctx, req.(*SetBadgeDisplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AchievementService_ServiceDesc is the grpc.ServiceDesc for AchievementService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AchievementService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AchievementService",
	HandlerType: (*AchievementServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListAchievements",
			Handler:    _AchievementService_ListAchievements_Handler,
		},
		{
			MethodName: "ConsumeAchievementEvent",
			Handler:    _AchievementService_ConsumeAchievementEvent_Handler,
		},
		{
			MethodName: "ListMyBadges",
			Handler:    _AchievementService_ListMyBadges_Handler,
		},
		{
			MethodName: "SetBadgeDisplay",
			Handler:    _AchievementService_SetBadgeDisplay_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	LuckyGiftService_CheckLuckyGift_FullMethodName       = "/hyapp.activity.v1.LuckyGiftService/CheckLuckyGift"
	LuckyGiftService_ExecuteLuckyGiftDraw_FullMethodName = "/hyapp.activity.v1.LuckyGiftService/ExecuteLuckyGiftDraw"
)

// LuckyGiftServiceClient is the client API for LuckyGiftService 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.
//
// LuckyGiftService owns lucky gift rule checks and draw decisions after wallet debit succeeds.
type LuckyGiftServiceClient interface {
	CheckLuckyGift(ctx context.Context, in *CheckLuckyGiftRequest, opts ...grpc.CallOption) (*CheckLuckyGiftResponse, error)
	ExecuteLuckyGiftDraw(ctx context.Context, in *ExecuteLuckyGiftDrawRequest, opts ...grpc.CallOption) (*ExecuteLuckyGiftDrawResponse, error)
}

type luckyGiftServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewLuckyGiftServiceClient(cc grpc.ClientConnInterface) LuckyGiftServiceClient {
	return &luckyGiftServiceClient{cc}
}

func (c *luckyGiftServiceClient) CheckLuckyGift(ctx context.Context, in *CheckLuckyGiftRequest, opts ...grpc.CallOption) (*CheckLuckyGiftResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CheckLuckyGiftResponse)
	err := c.cc.Invoke(ctx, LuckyGiftService_CheckLuckyGift_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *luckyGiftServiceClient) ExecuteLuckyGiftDraw(ctx context.Context, in *ExecuteLuckyGiftDrawRequest, opts ...grpc.CallOption) (*ExecuteLuckyGiftDrawResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ExecuteLuckyGiftDrawResponse)
	err := c.cc.Invoke(ctx, LuckyGiftService_ExecuteLuckyGiftDraw_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// LuckyGiftServiceServer is the server API for LuckyGiftService service.
// All implementations must embed UnimplementedLuckyGiftServiceServer
// for forward compatibility.
//
// LuckyGiftService owns lucky gift rule checks and draw decisions after wallet debit succeeds.
type LuckyGiftServiceServer interface {
	CheckLuckyGift(context.Context, *CheckLuckyGiftRequest) (*CheckLuckyGiftResponse, error)
	ExecuteLuckyGiftDraw(context.Context, *ExecuteLuckyGiftDrawRequest) (*ExecuteLuckyGiftDrawResponse, error)
	mustEmbedUnimplementedLuckyGiftServiceServer()
}

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

func (UnimplementedLuckyGiftServiceServer) CheckLuckyGift(context.Context, *CheckLuckyGiftRequest) (*CheckLuckyGiftResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CheckLuckyGift not implemented")
}
func (UnimplementedLuckyGiftServiceServer) ExecuteLuckyGiftDraw(context.Context, *ExecuteLuckyGiftDrawRequest) (*ExecuteLuckyGiftDrawResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ExecuteLuckyGiftDraw not implemented")
}
func (UnimplementedLuckyGiftServiceServer) mustEmbedUnimplementedLuckyGiftServiceServer() {}
func (UnimplementedLuckyGiftServiceServer) testEmbeddedByValue()                          {}

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

func RegisterLuckyGiftServiceServer(s grpc.ServiceRegistrar, srv LuckyGiftServiceServer) {
	// If the following call panics, it indicates UnimplementedLuckyGiftServiceServer 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(&LuckyGiftService_ServiceDesc, srv)
}

func _LuckyGiftService_CheckLuckyGift_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CheckLuckyGiftRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LuckyGiftServiceServer).CheckLuckyGift(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: LuckyGiftService_CheckLuckyGift_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LuckyGiftServiceServer).CheckLuckyGift(ctx, req.(*CheckLuckyGiftRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _LuckyGiftService_ExecuteLuckyGiftDraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecuteLuckyGiftDrawRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LuckyGiftServiceServer).ExecuteLuckyGiftDraw(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: LuckyGiftService_ExecuteLuckyGiftDraw_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LuckyGiftServiceServer).ExecuteLuckyGiftDraw(ctx, req.(*ExecuteLuckyGiftDrawRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// LuckyGiftService_ServiceDesc is the grpc.ServiceDesc for LuckyGiftService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var LuckyGiftService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.LuckyGiftService",
	HandlerType: (*LuckyGiftServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CheckLuckyGift",
			Handler:    _LuckyGiftService_CheckLuckyGift_Handler,
		},
		{
			MethodName: "ExecuteLuckyGiftDraw",
			Handler:    _LuckyGiftService_ExecuteLuckyGiftDraw_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	BroadcastService_EnsureBroadcastGroups_FullMethodName       = "/hyapp.activity.v1.BroadcastService/EnsureBroadcastGroups"
	BroadcastService_PublishRegionBroadcast_FullMethodName      = "/hyapp.activity.v1.BroadcastService/PublishRegionBroadcast"
	BroadcastService_PublishGlobalBroadcast_FullMethodName      = "/hyapp.activity.v1.BroadcastService/PublishGlobalBroadcast"
	BroadcastService_RemoveRegionBroadcastMember_FullMethodName = "/hyapp.activity.v1.BroadcastService/RemoveRegionBroadcastMember"
	BroadcastService_ProcessBroadcastOutboxBatch_FullMethodName = "/hyapp.activity.v1.BroadcastService/ProcessBroadcastOutboxBatch"
)

// BroadcastServiceClient is the client API for BroadcastService 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.
//
// BroadcastService owns server-side Tencent IM global/region broadcast delivery.
type BroadcastServiceClient interface {
	EnsureBroadcastGroups(ctx context.Context, in *EnsureBroadcastGroupsRequest, opts ...grpc.CallOption) (*EnsureBroadcastGroupsResponse, error)
	PublishRegionBroadcast(ctx context.Context, in *PublishRegionBroadcastRequest, opts ...grpc.CallOption) (*PublishBroadcastResponse, error)
	PublishGlobalBroadcast(ctx context.Context, in *PublishGlobalBroadcastRequest, opts ...grpc.CallOption) (*PublishBroadcastResponse, error)
	RemoveRegionBroadcastMember(ctx context.Context, in *RemoveRegionBroadcastMemberRequest, opts ...grpc.CallOption) (*RemoveRegionBroadcastMemberResponse, error)
	ProcessBroadcastOutboxBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*ProcessBroadcastOutboxBatchResponse, error)
}

type broadcastServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewBroadcastServiceClient(cc grpc.ClientConnInterface) BroadcastServiceClient {
	return &broadcastServiceClient{cc}
}

func (c *broadcastServiceClient) EnsureBroadcastGroups(ctx context.Context, in *EnsureBroadcastGroupsRequest, opts ...grpc.CallOption) (*EnsureBroadcastGroupsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EnsureBroadcastGroupsResponse)
	err := c.cc.Invoke(ctx, BroadcastService_EnsureBroadcastGroups_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *broadcastServiceClient) PublishRegionBroadcast(ctx context.Context, in *PublishRegionBroadcastRequest, opts ...grpc.CallOption) (*PublishBroadcastResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PublishBroadcastResponse)
	err := c.cc.Invoke(ctx, BroadcastService_PublishRegionBroadcast_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *broadcastServiceClient) PublishGlobalBroadcast(ctx context.Context, in *PublishGlobalBroadcastRequest, opts ...grpc.CallOption) (*PublishBroadcastResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PublishBroadcastResponse)
	err := c.cc.Invoke(ctx, BroadcastService_PublishGlobalBroadcast_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *broadcastServiceClient) RemoveRegionBroadcastMember(ctx context.Context, in *RemoveRegionBroadcastMemberRequest, opts ...grpc.CallOption) (*RemoveRegionBroadcastMemberResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RemoveRegionBroadcastMemberResponse)
	err := c.cc.Invoke(ctx, BroadcastService_RemoveRegionBroadcastMember_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *broadcastServiceClient) ProcessBroadcastOutboxBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*ProcessBroadcastOutboxBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ProcessBroadcastOutboxBatchResponse)
	err := c.cc.Invoke(ctx, BroadcastService_ProcessBroadcastOutboxBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BroadcastServiceServer is the server API for BroadcastService service.
// All implementations must embed UnimplementedBroadcastServiceServer
// for forward compatibility.
//
// BroadcastService owns server-side Tencent IM global/region broadcast delivery.
type BroadcastServiceServer interface {
	EnsureBroadcastGroups(context.Context, *EnsureBroadcastGroupsRequest) (*EnsureBroadcastGroupsResponse, error)
	PublishRegionBroadcast(context.Context, *PublishRegionBroadcastRequest) (*PublishBroadcastResponse, error)
	PublishGlobalBroadcast(context.Context, *PublishGlobalBroadcastRequest) (*PublishBroadcastResponse, error)
	RemoveRegionBroadcastMember(context.Context, *RemoveRegionBroadcastMemberRequest) (*RemoveRegionBroadcastMemberResponse, error)
	ProcessBroadcastOutboxBatch(context.Context, *CronBatchRequest) (*ProcessBroadcastOutboxBatchResponse, error)
	mustEmbedUnimplementedBroadcastServiceServer()
}

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

func (UnimplementedBroadcastServiceServer) EnsureBroadcastGroups(context.Context, *EnsureBroadcastGroupsRequest) (*EnsureBroadcastGroupsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method EnsureBroadcastGroups not implemented")
}
func (UnimplementedBroadcastServiceServer) PublishRegionBroadcast(context.Context, *PublishRegionBroadcastRequest) (*PublishBroadcastResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method PublishRegionBroadcast not implemented")
}
func (UnimplementedBroadcastServiceServer) PublishGlobalBroadcast(context.Context, *PublishGlobalBroadcastRequest) (*PublishBroadcastResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method PublishGlobalBroadcast not implemented")
}
func (UnimplementedBroadcastServiceServer) RemoveRegionBroadcastMember(context.Context, *RemoveRegionBroadcastMemberRequest) (*RemoveRegionBroadcastMemberResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method RemoveRegionBroadcastMember not implemented")
}
func (UnimplementedBroadcastServiceServer) ProcessBroadcastOutboxBatch(context.Context, *CronBatchRequest) (*ProcessBroadcastOutboxBatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ProcessBroadcastOutboxBatch not implemented")
}
func (UnimplementedBroadcastServiceServer) mustEmbedUnimplementedBroadcastServiceServer() {}
func (UnimplementedBroadcastServiceServer) testEmbeddedByValue()                          {}

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

func RegisterBroadcastServiceServer(s grpc.ServiceRegistrar, srv BroadcastServiceServer) {
	// If the following call panics, it indicates UnimplementedBroadcastServiceServer 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(&BroadcastService_ServiceDesc, srv)
}

func _BroadcastService_EnsureBroadcastGroups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnsureBroadcastGroupsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServiceServer).EnsureBroadcastGroups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BroadcastService_EnsureBroadcastGroups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServiceServer).EnsureBroadcastGroups(ctx, req.(*EnsureBroadcastGroupsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BroadcastService_PublishRegionBroadcast_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublishRegionBroadcastRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServiceServer).PublishRegionBroadcast(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BroadcastService_PublishRegionBroadcast_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServiceServer).PublishRegionBroadcast(ctx, req.(*PublishRegionBroadcastRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BroadcastService_PublishGlobalBroadcast_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublishGlobalBroadcastRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServiceServer).PublishGlobalBroadcast(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BroadcastService_PublishGlobalBroadcast_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServiceServer).PublishGlobalBroadcast(ctx, req.(*PublishGlobalBroadcastRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BroadcastService_RemoveRegionBroadcastMember_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveRegionBroadcastMemberRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServiceServer).RemoveRegionBroadcastMember(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BroadcastService_RemoveRegionBroadcastMember_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServiceServer).RemoveRegionBroadcastMember(ctx, req.(*RemoveRegionBroadcastMemberRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BroadcastService_ProcessBroadcastOutboxBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CronBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BroadcastServiceServer).ProcessBroadcastOutboxBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BroadcastService_ProcessBroadcastOutboxBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BroadcastServiceServer).ProcessBroadcastOutboxBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// BroadcastService_ServiceDesc is the grpc.ServiceDesc for BroadcastService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var BroadcastService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.BroadcastService",
	HandlerType: (*BroadcastServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "EnsureBroadcastGroups",
			Handler:    _BroadcastService_EnsureBroadcastGroups_Handler,
		},
		{
			MethodName: "PublishRegionBroadcast",
			Handler:    _BroadcastService_PublishRegionBroadcast_Handler,
		},
		{
			MethodName: "PublishGlobalBroadcast",
			Handler:    _BroadcastService_PublishGlobalBroadcast_Handler,
		},
		{
			MethodName: "RemoveRegionBroadcastMember",
			Handler:    _BroadcastService_RemoveRegionBroadcastMember_Handler,
		},
		{
			MethodName: "ProcessBroadcastOutboxBatch",
			Handler:    _BroadcastService_ProcessBroadcastOutboxBatch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	RoomEventConsumerService_ConsumeRoomEvent_FullMethodName = "/hyapp.activity.v1.RoomEventConsumerService/ConsumeRoomEvent"
)

// RoomEventConsumerServiceClient is the client API for RoomEventConsumerService 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.
//
// RoomEventConsumerService consumes room-service outbox facts without owning Room Cell state.
type RoomEventConsumerServiceClient interface {
	ConsumeRoomEvent(ctx context.Context, in *ConsumeRoomEventRequest, opts ...grpc.CallOption) (*ConsumeRoomEventResponse, error)
}

type roomEventConsumerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRoomEventConsumerServiceClient(cc grpc.ClientConnInterface) RoomEventConsumerServiceClient {
	return &roomEventConsumerServiceClient{cc}
}

func (c *roomEventConsumerServiceClient) ConsumeRoomEvent(ctx context.Context, in *ConsumeRoomEventRequest, opts ...grpc.CallOption) (*ConsumeRoomEventResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConsumeRoomEventResponse)
	err := c.cc.Invoke(ctx, RoomEventConsumerService_ConsumeRoomEvent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RoomEventConsumerServiceServer is the server API for RoomEventConsumerService service.
// All implementations must embed UnimplementedRoomEventConsumerServiceServer
// for forward compatibility.
//
// RoomEventConsumerService consumes room-service outbox facts without owning Room Cell state.
type RoomEventConsumerServiceServer interface {
	ConsumeRoomEvent(context.Context, *ConsumeRoomEventRequest) (*ConsumeRoomEventResponse, error)
	mustEmbedUnimplementedRoomEventConsumerServiceServer()
}

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

func (UnimplementedRoomEventConsumerServiceServer) ConsumeRoomEvent(context.Context, *ConsumeRoomEventRequest) (*ConsumeRoomEventResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ConsumeRoomEvent not implemented")
}
func (UnimplementedRoomEventConsumerServiceServer) mustEmbedUnimplementedRoomEventConsumerServiceServer() {
}
func (UnimplementedRoomEventConsumerServiceServer) testEmbeddedByValue() {}

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

func RegisterRoomEventConsumerServiceServer(s grpc.ServiceRegistrar, srv RoomEventConsumerServiceServer) {
	// If the following call panics, it indicates UnimplementedRoomEventConsumerServiceServer 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(&RoomEventConsumerService_ServiceDesc, srv)
}

func _RoomEventConsumerService_ConsumeRoomEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumeRoomEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoomEventConsumerServiceServer).ConsumeRoomEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RoomEventConsumerService_ConsumeRoomEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoomEventConsumerServiceServer).ConsumeRoomEvent(ctx, req.(*ConsumeRoomEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RoomEventConsumerService_ServiceDesc is the grpc.ServiceDesc for RoomEventConsumerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RoomEventConsumerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.RoomEventConsumerService",
	HandlerType: (*RoomEventConsumerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ConsumeRoomEvent",
			Handler:    _RoomEventConsumerService_ConsumeRoomEvent_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminTaskService_ListTaskDefinitions_FullMethodName     = "/hyapp.activity.v1.AdminTaskService/ListTaskDefinitions"
	AdminTaskService_UpsertTaskDefinition_FullMethodName    = "/hyapp.activity.v1.AdminTaskService/UpsertTaskDefinition"
	AdminTaskService_SetTaskDefinitionStatus_FullMethodName = "/hyapp.activity.v1.AdminTaskService/SetTaskDefinitionStatus"
)

// AdminTaskServiceClient is the client API for AdminTaskService 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.
//
// AdminTaskService 是后台活动管理访问 activity-service 的唯一任务配置入口。
type AdminTaskServiceClient interface {
	ListTaskDefinitions(ctx context.Context, in *ListTaskDefinitionsRequest, opts ...grpc.CallOption) (*ListTaskDefinitionsResponse, error)
	UpsertTaskDefinition(ctx context.Context, in *UpsertTaskDefinitionRequest, opts ...grpc.CallOption) (*UpsertTaskDefinitionResponse, error)
	SetTaskDefinitionStatus(ctx context.Context, in *SetTaskDefinitionStatusRequest, opts ...grpc.CallOption) (*SetTaskDefinitionStatusResponse, error)
}

type adminTaskServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminTaskServiceClient(cc grpc.ClientConnInterface) AdminTaskServiceClient {
	return &adminTaskServiceClient{cc}
}

func (c *adminTaskServiceClient) ListTaskDefinitions(ctx context.Context, in *ListTaskDefinitionsRequest, opts ...grpc.CallOption) (*ListTaskDefinitionsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTaskDefinitionsResponse)
	err := c.cc.Invoke(ctx, AdminTaskService_ListTaskDefinitions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminTaskServiceClient) UpsertTaskDefinition(ctx context.Context, in *UpsertTaskDefinitionRequest, opts ...grpc.CallOption) (*UpsertTaskDefinitionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertTaskDefinitionResponse)
	err := c.cc.Invoke(ctx, AdminTaskService_UpsertTaskDefinition_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminTaskServiceClient) SetTaskDefinitionStatus(ctx context.Context, in *SetTaskDefinitionStatusRequest, opts ...grpc.CallOption) (*SetTaskDefinitionStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetTaskDefinitionStatusResponse)
	err := c.cc.Invoke(ctx, AdminTaskService_SetTaskDefinitionStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminTaskServiceServer is the server API for AdminTaskService service.
// All implementations must embed UnimplementedAdminTaskServiceServer
// for forward compatibility.
//
// AdminTaskService 是后台活动管理访问 activity-service 的唯一任务配置入口。
type AdminTaskServiceServer interface {
	ListTaskDefinitions(context.Context, *ListTaskDefinitionsRequest) (*ListTaskDefinitionsResponse, error)
	UpsertTaskDefinition(context.Context, *UpsertTaskDefinitionRequest) (*UpsertTaskDefinitionResponse, error)
	SetTaskDefinitionStatus(context.Context, *SetTaskDefinitionStatusRequest) (*SetTaskDefinitionStatusResponse, error)
	mustEmbedUnimplementedAdminTaskServiceServer()
}

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

func (UnimplementedAdminTaskServiceServer) ListTaskDefinitions(context.Context, *ListTaskDefinitionsRequest) (*ListTaskDefinitionsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListTaskDefinitions not implemented")
}
func (UnimplementedAdminTaskServiceServer) UpsertTaskDefinition(context.Context, *UpsertTaskDefinitionRequest) (*UpsertTaskDefinitionResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertTaskDefinition not implemented")
}
func (UnimplementedAdminTaskServiceServer) SetTaskDefinitionStatus(context.Context, *SetTaskDefinitionStatusRequest) (*SetTaskDefinitionStatusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SetTaskDefinitionStatus not implemented")
}
func (UnimplementedAdminTaskServiceServer) mustEmbedUnimplementedAdminTaskServiceServer() {}
func (UnimplementedAdminTaskServiceServer) testEmbeddedByValue()                          {}

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

func RegisterAdminTaskServiceServer(s grpc.ServiceRegistrar, srv AdminTaskServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminTaskServiceServer 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(&AdminTaskService_ServiceDesc, srv)
}

func _AdminTaskService_ListTaskDefinitions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTaskDefinitionsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminTaskServiceServer).ListTaskDefinitions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminTaskService_ListTaskDefinitions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminTaskServiceServer).ListTaskDefinitions(ctx, req.(*ListTaskDefinitionsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminTaskService_UpsertTaskDefinition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertTaskDefinitionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminTaskServiceServer).UpsertTaskDefinition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminTaskService_UpsertTaskDefinition_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminTaskServiceServer).UpsertTaskDefinition(ctx, req.(*UpsertTaskDefinitionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminTaskService_SetTaskDefinitionStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTaskDefinitionStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminTaskServiceServer).SetTaskDefinitionStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminTaskService_SetTaskDefinitionStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminTaskServiceServer).SetTaskDefinitionStatus(ctx, req.(*SetTaskDefinitionStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminTaskService_ServiceDesc is the grpc.ServiceDesc for AdminTaskService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminTaskService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminTaskService",
	HandlerType: (*AdminTaskServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListTaskDefinitions",
			Handler:    _AdminTaskService_ListTaskDefinitions_Handler,
		},
		{
			MethodName: "UpsertTaskDefinition",
			Handler:    _AdminTaskService_UpsertTaskDefinition_Handler,
		},
		{
			MethodName: "SetTaskDefinitionStatus",
			Handler:    _AdminTaskService_SetTaskDefinitionStatus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	RegistrationRewardService_GetRegistrationRewardEligibility_FullMethodName = "/hyapp.activity.v1.RegistrationRewardService/GetRegistrationRewardEligibility"
	RegistrationRewardService_IssueRegistrationReward_FullMethodName          = "/hyapp.activity.v1.RegistrationRewardService/IssueRegistrationReward"
)

// RegistrationRewardServiceClient is the client API for RegistrationRewardService 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.
//
// RegistrationRewardService 拥有 App 查询和注册完成发放入口。
type RegistrationRewardServiceClient interface {
	GetRegistrationRewardEligibility(ctx context.Context, in *GetRegistrationRewardEligibilityRequest, opts ...grpc.CallOption) (*GetRegistrationRewardEligibilityResponse, error)
	IssueRegistrationReward(ctx context.Context, in *IssueRegistrationRewardRequest, opts ...grpc.CallOption) (*IssueRegistrationRewardResponse, error)
}

type registrationRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRegistrationRewardServiceClient(cc grpc.ClientConnInterface) RegistrationRewardServiceClient {
	return &registrationRewardServiceClient{cc}
}

func (c *registrationRewardServiceClient) GetRegistrationRewardEligibility(ctx context.Context, in *GetRegistrationRewardEligibilityRequest, opts ...grpc.CallOption) (*GetRegistrationRewardEligibilityResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetRegistrationRewardEligibilityResponse)
	err := c.cc.Invoke(ctx, RegistrationRewardService_GetRegistrationRewardEligibility_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *registrationRewardServiceClient) IssueRegistrationReward(ctx context.Context, in *IssueRegistrationRewardRequest, opts ...grpc.CallOption) (*IssueRegistrationRewardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IssueRegistrationRewardResponse)
	err := c.cc.Invoke(ctx, RegistrationRewardService_IssueRegistrationReward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RegistrationRewardServiceServer is the server API for RegistrationRewardService service.
// All implementations must embed UnimplementedRegistrationRewardServiceServer
// for forward compatibility.
//
// RegistrationRewardService 拥有 App 查询和注册完成发放入口。
type RegistrationRewardServiceServer interface {
	GetRegistrationRewardEligibility(context.Context, *GetRegistrationRewardEligibilityRequest) (*GetRegistrationRewardEligibilityResponse, error)
	IssueRegistrationReward(context.Context, *IssueRegistrationRewardRequest) (*IssueRegistrationRewardResponse, error)
	mustEmbedUnimplementedRegistrationRewardServiceServer()
}

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

func (UnimplementedRegistrationRewardServiceServer) GetRegistrationRewardEligibility(context.Context, *GetRegistrationRewardEligibilityRequest) (*GetRegistrationRewardEligibilityResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRegistrationRewardEligibility not implemented")
}
func (UnimplementedRegistrationRewardServiceServer) IssueRegistrationReward(context.Context, *IssueRegistrationRewardRequest) (*IssueRegistrationRewardResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method IssueRegistrationReward not implemented")
}
func (UnimplementedRegistrationRewardServiceServer) mustEmbedUnimplementedRegistrationRewardServiceServer() {
}
func (UnimplementedRegistrationRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterRegistrationRewardServiceServer(s grpc.ServiceRegistrar, srv RegistrationRewardServiceServer) {
	// If the following call panics, it indicates UnimplementedRegistrationRewardServiceServer 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(&RegistrationRewardService_ServiceDesc, srv)
}

func _RegistrationRewardService_GetRegistrationRewardEligibility_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRegistrationRewardEligibilityRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegistrationRewardServiceServer).GetRegistrationRewardEligibility(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegistrationRewardService_GetRegistrationRewardEligibility_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegistrationRewardServiceServer).GetRegistrationRewardEligibility(ctx, req.(*GetRegistrationRewardEligibilityRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RegistrationRewardService_IssueRegistrationReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IssueRegistrationRewardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RegistrationRewardServiceServer).IssueRegistrationReward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RegistrationRewardService_IssueRegistrationReward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RegistrationRewardServiceServer).IssueRegistrationReward(ctx, req.(*IssueRegistrationRewardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// RegistrationRewardService_ServiceDesc is the grpc.ServiceDesc for RegistrationRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RegistrationRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.RegistrationRewardService",
	HandlerType: (*RegistrationRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRegistrationRewardEligibility",
			Handler:    _RegistrationRewardService_GetRegistrationRewardEligibility_Handler,
		},
		{
			MethodName: "IssueRegistrationReward",
			Handler:    _RegistrationRewardService_IssueRegistrationReward_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminRegistrationRewardService_GetRegistrationRewardConfig_FullMethodName    = "/hyapp.activity.v1.AdminRegistrationRewardService/GetRegistrationRewardConfig"
	AdminRegistrationRewardService_UpdateRegistrationRewardConfig_FullMethodName = "/hyapp.activity.v1.AdminRegistrationRewardService/UpdateRegistrationRewardConfig"
	AdminRegistrationRewardService_ListRegistrationRewardClaims_FullMethodName   = "/hyapp.activity.v1.AdminRegistrationRewardService/ListRegistrationRewardClaims"
)

// AdminRegistrationRewardServiceClient is the client API for AdminRegistrationRewardService 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.
//
// AdminRegistrationRewardService 是后台活动管理访问注册奖励配置和领取记录的唯一入口。
type AdminRegistrationRewardServiceClient interface {
	GetRegistrationRewardConfig(ctx context.Context, in *GetRegistrationRewardConfigRequest, opts ...grpc.CallOption) (*GetRegistrationRewardConfigResponse, error)
	UpdateRegistrationRewardConfig(ctx context.Context, in *UpdateRegistrationRewardConfigRequest, opts ...grpc.CallOption) (*UpdateRegistrationRewardConfigResponse, error)
	ListRegistrationRewardClaims(ctx context.Context, in *ListRegistrationRewardClaimsRequest, opts ...grpc.CallOption) (*ListRegistrationRewardClaimsResponse, error)
}

type adminRegistrationRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminRegistrationRewardServiceClient(cc grpc.ClientConnInterface) AdminRegistrationRewardServiceClient {
	return &adminRegistrationRewardServiceClient{cc}
}

func (c *adminRegistrationRewardServiceClient) GetRegistrationRewardConfig(ctx context.Context, in *GetRegistrationRewardConfigRequest, opts ...grpc.CallOption) (*GetRegistrationRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetRegistrationRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminRegistrationRewardService_GetRegistrationRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminRegistrationRewardServiceClient) UpdateRegistrationRewardConfig(ctx context.Context, in *UpdateRegistrationRewardConfigRequest, opts ...grpc.CallOption) (*UpdateRegistrationRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateRegistrationRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminRegistrationRewardService_UpdateRegistrationRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminRegistrationRewardServiceClient) ListRegistrationRewardClaims(ctx context.Context, in *ListRegistrationRewardClaimsRequest, opts ...grpc.CallOption) (*ListRegistrationRewardClaimsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListRegistrationRewardClaimsResponse)
	err := c.cc.Invoke(ctx, AdminRegistrationRewardService_ListRegistrationRewardClaims_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminRegistrationRewardServiceServer is the server API for AdminRegistrationRewardService service.
// All implementations must embed UnimplementedAdminRegistrationRewardServiceServer
// for forward compatibility.
//
// AdminRegistrationRewardService 是后台活动管理访问注册奖励配置和领取记录的唯一入口。
type AdminRegistrationRewardServiceServer interface {
	GetRegistrationRewardConfig(context.Context, *GetRegistrationRewardConfigRequest) (*GetRegistrationRewardConfigResponse, error)
	UpdateRegistrationRewardConfig(context.Context, *UpdateRegistrationRewardConfigRequest) (*UpdateRegistrationRewardConfigResponse, error)
	ListRegistrationRewardClaims(context.Context, *ListRegistrationRewardClaimsRequest) (*ListRegistrationRewardClaimsResponse, error)
	mustEmbedUnimplementedAdminRegistrationRewardServiceServer()
}

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

func (UnimplementedAdminRegistrationRewardServiceServer) GetRegistrationRewardConfig(context.Context, *GetRegistrationRewardConfigRequest) (*GetRegistrationRewardConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRegistrationRewardConfig not implemented")
}
func (UnimplementedAdminRegistrationRewardServiceServer) UpdateRegistrationRewardConfig(context.Context, *UpdateRegistrationRewardConfigRequest) (*UpdateRegistrationRewardConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateRegistrationRewardConfig not implemented")
}
func (UnimplementedAdminRegistrationRewardServiceServer) ListRegistrationRewardClaims(context.Context, *ListRegistrationRewardClaimsRequest) (*ListRegistrationRewardClaimsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListRegistrationRewardClaims not implemented")
}
func (UnimplementedAdminRegistrationRewardServiceServer) mustEmbedUnimplementedAdminRegistrationRewardServiceServer() {
}
func (UnimplementedAdminRegistrationRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminRegistrationRewardServiceServer(s grpc.ServiceRegistrar, srv AdminRegistrationRewardServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminRegistrationRewardServiceServer 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(&AdminRegistrationRewardService_ServiceDesc, srv)
}

func _AdminRegistrationRewardService_GetRegistrationRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRegistrationRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRegistrationRewardServiceServer).GetRegistrationRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRegistrationRewardService_GetRegistrationRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRegistrationRewardServiceServer).GetRegistrationRewardConfig(ctx, req.(*GetRegistrationRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminRegistrationRewardService_UpdateRegistrationRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRegistrationRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRegistrationRewardServiceServer).UpdateRegistrationRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRegistrationRewardService_UpdateRegistrationRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRegistrationRewardServiceServer).UpdateRegistrationRewardConfig(ctx, req.(*UpdateRegistrationRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminRegistrationRewardService_ListRegistrationRewardClaims_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRegistrationRewardClaimsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRegistrationRewardServiceServer).ListRegistrationRewardClaims(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRegistrationRewardService_ListRegistrationRewardClaims_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRegistrationRewardServiceServer).ListRegistrationRewardClaims(ctx, req.(*ListRegistrationRewardClaimsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminRegistrationRewardService_ServiceDesc is the grpc.ServiceDesc for AdminRegistrationRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminRegistrationRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminRegistrationRewardService",
	HandlerType: (*AdminRegistrationRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRegistrationRewardConfig",
			Handler:    _AdminRegistrationRewardService_GetRegistrationRewardConfig_Handler,
		},
		{
			MethodName: "UpdateRegistrationRewardConfig",
			Handler:    _AdminRegistrationRewardService_UpdateRegistrationRewardConfig_Handler,
		},
		{
			MethodName: "ListRegistrationRewardClaims",
			Handler:    _AdminRegistrationRewardService_ListRegistrationRewardClaims_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	FirstRechargeRewardService_GetFirstRechargeRewardStatus_FullMethodName = "/hyapp.activity.v1.FirstRechargeRewardService/GetFirstRechargeRewardStatus"
	FirstRechargeRewardService_ConsumeFirstRechargeReward_FullMethodName   = "/hyapp.activity.v1.FirstRechargeRewardService/ConsumeFirstRechargeReward"
)

// FirstRechargeRewardServiceClient is the client API for FirstRechargeRewardService 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.
//
// FirstRechargeRewardService 拥有 App 首冲奖励查询和 wallet 充值事实消费入口。
type FirstRechargeRewardServiceClient interface {
	GetFirstRechargeRewardStatus(ctx context.Context, in *GetFirstRechargeRewardStatusRequest, opts ...grpc.CallOption) (*GetFirstRechargeRewardStatusResponse, error)
	ConsumeFirstRechargeReward(ctx context.Context, in *ConsumeFirstRechargeRewardRequest, opts ...grpc.CallOption) (*ConsumeFirstRechargeRewardResponse, error)
}

type firstRechargeRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewFirstRechargeRewardServiceClient(cc grpc.ClientConnInterface) FirstRechargeRewardServiceClient {
	return &firstRechargeRewardServiceClient{cc}
}

func (c *firstRechargeRewardServiceClient) GetFirstRechargeRewardStatus(ctx context.Context, in *GetFirstRechargeRewardStatusRequest, opts ...grpc.CallOption) (*GetFirstRechargeRewardStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetFirstRechargeRewardStatusResponse)
	err := c.cc.Invoke(ctx, FirstRechargeRewardService_GetFirstRechargeRewardStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *firstRechargeRewardServiceClient) ConsumeFirstRechargeReward(ctx context.Context, in *ConsumeFirstRechargeRewardRequest, opts ...grpc.CallOption) (*ConsumeFirstRechargeRewardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConsumeFirstRechargeRewardResponse)
	err := c.cc.Invoke(ctx, FirstRechargeRewardService_ConsumeFirstRechargeReward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// FirstRechargeRewardServiceServer is the server API for FirstRechargeRewardService service.
// All implementations must embed UnimplementedFirstRechargeRewardServiceServer
// for forward compatibility.
//
// FirstRechargeRewardService 拥有 App 首冲奖励查询和 wallet 充值事实消费入口。
type FirstRechargeRewardServiceServer interface {
	GetFirstRechargeRewardStatus(context.Context, *GetFirstRechargeRewardStatusRequest) (*GetFirstRechargeRewardStatusResponse, error)
	ConsumeFirstRechargeReward(context.Context, *ConsumeFirstRechargeRewardRequest) (*ConsumeFirstRechargeRewardResponse, error)
	mustEmbedUnimplementedFirstRechargeRewardServiceServer()
}

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

func (UnimplementedFirstRechargeRewardServiceServer) GetFirstRechargeRewardStatus(context.Context, *GetFirstRechargeRewardStatusRequest) (*GetFirstRechargeRewardStatusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetFirstRechargeRewardStatus not implemented")
}
func (UnimplementedFirstRechargeRewardServiceServer) ConsumeFirstRechargeReward(context.Context, *ConsumeFirstRechargeRewardRequest) (*ConsumeFirstRechargeRewardResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ConsumeFirstRechargeReward not implemented")
}
func (UnimplementedFirstRechargeRewardServiceServer) mustEmbedUnimplementedFirstRechargeRewardServiceServer() {
}
func (UnimplementedFirstRechargeRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterFirstRechargeRewardServiceServer(s grpc.ServiceRegistrar, srv FirstRechargeRewardServiceServer) {
	// If the following call panics, it indicates UnimplementedFirstRechargeRewardServiceServer 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(&FirstRechargeRewardService_ServiceDesc, srv)
}

func _FirstRechargeRewardService_GetFirstRechargeRewardStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetFirstRechargeRewardStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FirstRechargeRewardServiceServer).GetFirstRechargeRewardStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FirstRechargeRewardService_GetFirstRechargeRewardStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FirstRechargeRewardServiceServer).GetFirstRechargeRewardStatus(ctx, req.(*GetFirstRechargeRewardStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _FirstRechargeRewardService_ConsumeFirstRechargeReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumeFirstRechargeRewardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(FirstRechargeRewardServiceServer).ConsumeFirstRechargeReward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: FirstRechargeRewardService_ConsumeFirstRechargeReward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(FirstRechargeRewardServiceServer).ConsumeFirstRechargeReward(ctx, req.(*ConsumeFirstRechargeRewardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// FirstRechargeRewardService_ServiceDesc is the grpc.ServiceDesc for FirstRechargeRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var FirstRechargeRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.FirstRechargeRewardService",
	HandlerType: (*FirstRechargeRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetFirstRechargeRewardStatus",
			Handler:    _FirstRechargeRewardService_GetFirstRechargeRewardStatus_Handler,
		},
		{
			MethodName: "ConsumeFirstRechargeReward",
			Handler:    _FirstRechargeRewardService_ConsumeFirstRechargeReward_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminFirstRechargeRewardService_GetFirstRechargeRewardConfig_FullMethodName    = "/hyapp.activity.v1.AdminFirstRechargeRewardService/GetFirstRechargeRewardConfig"
	AdminFirstRechargeRewardService_UpdateFirstRechargeRewardConfig_FullMethodName = "/hyapp.activity.v1.AdminFirstRechargeRewardService/UpdateFirstRechargeRewardConfig"
	AdminFirstRechargeRewardService_ListFirstRechargeRewardClaims_FullMethodName   = "/hyapp.activity.v1.AdminFirstRechargeRewardService/ListFirstRechargeRewardClaims"
)

// AdminFirstRechargeRewardServiceClient is the client API for AdminFirstRechargeRewardService 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.
//
// AdminFirstRechargeRewardService 是后台活动管理访问首冲奖励配置和发放记录的唯一入口。
type AdminFirstRechargeRewardServiceClient interface {
	GetFirstRechargeRewardConfig(ctx context.Context, in *GetFirstRechargeRewardConfigRequest, opts ...grpc.CallOption) (*GetFirstRechargeRewardConfigResponse, error)
	UpdateFirstRechargeRewardConfig(ctx context.Context, in *UpdateFirstRechargeRewardConfigRequest, opts ...grpc.CallOption) (*UpdateFirstRechargeRewardConfigResponse, error)
	ListFirstRechargeRewardClaims(ctx context.Context, in *ListFirstRechargeRewardClaimsRequest, opts ...grpc.CallOption) (*ListFirstRechargeRewardClaimsResponse, error)
}

type adminFirstRechargeRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminFirstRechargeRewardServiceClient(cc grpc.ClientConnInterface) AdminFirstRechargeRewardServiceClient {
	return &adminFirstRechargeRewardServiceClient{cc}
}

func (c *adminFirstRechargeRewardServiceClient) GetFirstRechargeRewardConfig(ctx context.Context, in *GetFirstRechargeRewardConfigRequest, opts ...grpc.CallOption) (*GetFirstRechargeRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetFirstRechargeRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminFirstRechargeRewardService_GetFirstRechargeRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminFirstRechargeRewardServiceClient) UpdateFirstRechargeRewardConfig(ctx context.Context, in *UpdateFirstRechargeRewardConfigRequest, opts ...grpc.CallOption) (*UpdateFirstRechargeRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateFirstRechargeRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminFirstRechargeRewardService_UpdateFirstRechargeRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminFirstRechargeRewardServiceClient) ListFirstRechargeRewardClaims(ctx context.Context, in *ListFirstRechargeRewardClaimsRequest, opts ...grpc.CallOption) (*ListFirstRechargeRewardClaimsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListFirstRechargeRewardClaimsResponse)
	err := c.cc.Invoke(ctx, AdminFirstRechargeRewardService_ListFirstRechargeRewardClaims_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminFirstRechargeRewardServiceServer is the server API for AdminFirstRechargeRewardService service.
// All implementations must embed UnimplementedAdminFirstRechargeRewardServiceServer
// for forward compatibility.
//
// AdminFirstRechargeRewardService 是后台活动管理访问首冲奖励配置和发放记录的唯一入口。
type AdminFirstRechargeRewardServiceServer interface {
	GetFirstRechargeRewardConfig(context.Context, *GetFirstRechargeRewardConfigRequest) (*GetFirstRechargeRewardConfigResponse, error)
	UpdateFirstRechargeRewardConfig(context.Context, *UpdateFirstRechargeRewardConfigRequest) (*UpdateFirstRechargeRewardConfigResponse, error)
	ListFirstRechargeRewardClaims(context.Context, *ListFirstRechargeRewardClaimsRequest) (*ListFirstRechargeRewardClaimsResponse, error)
	mustEmbedUnimplementedAdminFirstRechargeRewardServiceServer()
}

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

func (UnimplementedAdminFirstRechargeRewardServiceServer) GetFirstRechargeRewardConfig(context.Context, *GetFirstRechargeRewardConfigRequest) (*GetFirstRechargeRewardConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetFirstRechargeRewardConfig not implemented")
}
func (UnimplementedAdminFirstRechargeRewardServiceServer) UpdateFirstRechargeRewardConfig(context.Context, *UpdateFirstRechargeRewardConfigRequest) (*UpdateFirstRechargeRewardConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateFirstRechargeRewardConfig not implemented")
}
func (UnimplementedAdminFirstRechargeRewardServiceServer) ListFirstRechargeRewardClaims(context.Context, *ListFirstRechargeRewardClaimsRequest) (*ListFirstRechargeRewardClaimsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListFirstRechargeRewardClaims not implemented")
}
func (UnimplementedAdminFirstRechargeRewardServiceServer) mustEmbedUnimplementedAdminFirstRechargeRewardServiceServer() {
}
func (UnimplementedAdminFirstRechargeRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminFirstRechargeRewardServiceServer(s grpc.ServiceRegistrar, srv AdminFirstRechargeRewardServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminFirstRechargeRewardServiceServer 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(&AdminFirstRechargeRewardService_ServiceDesc, srv)
}

func _AdminFirstRechargeRewardService_GetFirstRechargeRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetFirstRechargeRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminFirstRechargeRewardServiceServer).GetFirstRechargeRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminFirstRechargeRewardService_GetFirstRechargeRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminFirstRechargeRewardServiceServer).GetFirstRechargeRewardConfig(ctx, req.(*GetFirstRechargeRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminFirstRechargeRewardService_UpdateFirstRechargeRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateFirstRechargeRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminFirstRechargeRewardServiceServer).UpdateFirstRechargeRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminFirstRechargeRewardService_UpdateFirstRechargeRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminFirstRechargeRewardServiceServer).UpdateFirstRechargeRewardConfig(ctx, req.(*UpdateFirstRechargeRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminFirstRechargeRewardService_ListFirstRechargeRewardClaims_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListFirstRechargeRewardClaimsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminFirstRechargeRewardServiceServer).ListFirstRechargeRewardClaims(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminFirstRechargeRewardService_ListFirstRechargeRewardClaims_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminFirstRechargeRewardServiceServer).ListFirstRechargeRewardClaims(ctx, req.(*ListFirstRechargeRewardClaimsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminFirstRechargeRewardService_ServiceDesc is the grpc.ServiceDesc for AdminFirstRechargeRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminFirstRechargeRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminFirstRechargeRewardService",
	HandlerType: (*AdminFirstRechargeRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetFirstRechargeRewardConfig",
			Handler:    _AdminFirstRechargeRewardService_GetFirstRechargeRewardConfig_Handler,
		},
		{
			MethodName: "UpdateFirstRechargeRewardConfig",
			Handler:    _AdminFirstRechargeRewardService_UpdateFirstRechargeRewardConfig_Handler,
		},
		{
			MethodName: "ListFirstRechargeRewardClaims",
			Handler:    _AdminFirstRechargeRewardService_ListFirstRechargeRewardClaims_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	SevenDayCheckInService_GetSevenDayCheckInStatus_FullMethodName = "/hyapp.activity.v1.SevenDayCheckInService/GetSevenDayCheckInStatus"
	SevenDayCheckInService_SignSevenDayCheckIn_FullMethodName      = "/hyapp.activity.v1.SevenDayCheckInService/SignSevenDayCheckIn"
)

// SevenDayCheckInServiceClient is the client API for SevenDayCheckInService 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.
//
// SevenDayCheckInService 拥有 App 七日签到查询和签到命令。
type SevenDayCheckInServiceClient interface {
	GetSevenDayCheckInStatus(ctx context.Context, in *GetSevenDayCheckInStatusRequest, opts ...grpc.CallOption) (*GetSevenDayCheckInStatusResponse, error)
	SignSevenDayCheckIn(ctx context.Context, in *SignSevenDayCheckInRequest, opts ...grpc.CallOption) (*SignSevenDayCheckInResponse, error)
}

type sevenDayCheckInServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSevenDayCheckInServiceClient(cc grpc.ClientConnInterface) SevenDayCheckInServiceClient {
	return &sevenDayCheckInServiceClient{cc}
}

func (c *sevenDayCheckInServiceClient) GetSevenDayCheckInStatus(ctx context.Context, in *GetSevenDayCheckInStatusRequest, opts ...grpc.CallOption) (*GetSevenDayCheckInStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSevenDayCheckInStatusResponse)
	err := c.cc.Invoke(ctx, SevenDayCheckInService_GetSevenDayCheckInStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sevenDayCheckInServiceClient) SignSevenDayCheckIn(ctx context.Context, in *SignSevenDayCheckInRequest, opts ...grpc.CallOption) (*SignSevenDayCheckInResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SignSevenDayCheckInResponse)
	err := c.cc.Invoke(ctx, SevenDayCheckInService_SignSevenDayCheckIn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SevenDayCheckInServiceServer is the server API for SevenDayCheckInService service.
// All implementations must embed UnimplementedSevenDayCheckInServiceServer
// for forward compatibility.
//
// SevenDayCheckInService 拥有 App 七日签到查询和签到命令。
type SevenDayCheckInServiceServer interface {
	GetSevenDayCheckInStatus(context.Context, *GetSevenDayCheckInStatusRequest) (*GetSevenDayCheckInStatusResponse, error)
	SignSevenDayCheckIn(context.Context, *SignSevenDayCheckInRequest) (*SignSevenDayCheckInResponse, error)
	mustEmbedUnimplementedSevenDayCheckInServiceServer()
}

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

func (UnimplementedSevenDayCheckInServiceServer) GetSevenDayCheckInStatus(context.Context, *GetSevenDayCheckInStatusRequest) (*GetSevenDayCheckInStatusResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSevenDayCheckInStatus not implemented")
}
func (UnimplementedSevenDayCheckInServiceServer) SignSevenDayCheckIn(context.Context, *SignSevenDayCheckInRequest) (*SignSevenDayCheckInResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SignSevenDayCheckIn not implemented")
}
func (UnimplementedSevenDayCheckInServiceServer) mustEmbedUnimplementedSevenDayCheckInServiceServer() {
}
func (UnimplementedSevenDayCheckInServiceServer) testEmbeddedByValue() {}

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

func RegisterSevenDayCheckInServiceServer(s grpc.ServiceRegistrar, srv SevenDayCheckInServiceServer) {
	// If the following call panics, it indicates UnimplementedSevenDayCheckInServiceServer 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(&SevenDayCheckInService_ServiceDesc, srv)
}

func _SevenDayCheckInService_GetSevenDayCheckInStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSevenDayCheckInStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SevenDayCheckInServiceServer).GetSevenDayCheckInStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SevenDayCheckInService_GetSevenDayCheckInStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SevenDayCheckInServiceServer).GetSevenDayCheckInStatus(ctx, req.(*GetSevenDayCheckInStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SevenDayCheckInService_SignSevenDayCheckIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignSevenDayCheckInRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SevenDayCheckInServiceServer).SignSevenDayCheckIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SevenDayCheckInService_SignSevenDayCheckIn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SevenDayCheckInServiceServer).SignSevenDayCheckIn(ctx, req.(*SignSevenDayCheckInRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SevenDayCheckInService_ServiceDesc is the grpc.ServiceDesc for SevenDayCheckInService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SevenDayCheckInService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.SevenDayCheckInService",
	HandlerType: (*SevenDayCheckInServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSevenDayCheckInStatus",
			Handler:    _SevenDayCheckInService_GetSevenDayCheckInStatus_Handler,
		},
		{
			MethodName: "SignSevenDayCheckIn",
			Handler:    _SevenDayCheckInService_SignSevenDayCheckIn_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminSevenDayCheckInService_GetSevenDayCheckInConfig_FullMethodName    = "/hyapp.activity.v1.AdminSevenDayCheckInService/GetSevenDayCheckInConfig"
	AdminSevenDayCheckInService_UpdateSevenDayCheckInConfig_FullMethodName = "/hyapp.activity.v1.AdminSevenDayCheckInService/UpdateSevenDayCheckInConfig"
	AdminSevenDayCheckInService_ListSevenDayCheckInClaims_FullMethodName   = "/hyapp.activity.v1.AdminSevenDayCheckInService/ListSevenDayCheckInClaims"
)

// AdminSevenDayCheckInServiceClient is the client API for AdminSevenDayCheckInService 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.
//
// AdminSevenDayCheckInService 是后台活动管理访问七日签到配置和领取记录的唯一入口。
type AdminSevenDayCheckInServiceClient interface {
	GetSevenDayCheckInConfig(ctx context.Context, in *GetSevenDayCheckInConfigRequest, opts ...grpc.CallOption) (*GetSevenDayCheckInConfigResponse, error)
	UpdateSevenDayCheckInConfig(ctx context.Context, in *UpdateSevenDayCheckInConfigRequest, opts ...grpc.CallOption) (*UpdateSevenDayCheckInConfigResponse, error)
	ListSevenDayCheckInClaims(ctx context.Context, in *ListSevenDayCheckInClaimsRequest, opts ...grpc.CallOption) (*ListSevenDayCheckInClaimsResponse, error)
}

type adminSevenDayCheckInServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminSevenDayCheckInServiceClient(cc grpc.ClientConnInterface) AdminSevenDayCheckInServiceClient {
	return &adminSevenDayCheckInServiceClient{cc}
}

func (c *adminSevenDayCheckInServiceClient) GetSevenDayCheckInConfig(ctx context.Context, in *GetSevenDayCheckInConfigRequest, opts ...grpc.CallOption) (*GetSevenDayCheckInConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSevenDayCheckInConfigResponse)
	err := c.cc.Invoke(ctx, AdminSevenDayCheckInService_GetSevenDayCheckInConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminSevenDayCheckInServiceClient) UpdateSevenDayCheckInConfig(ctx context.Context, in *UpdateSevenDayCheckInConfigRequest, opts ...grpc.CallOption) (*UpdateSevenDayCheckInConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateSevenDayCheckInConfigResponse)
	err := c.cc.Invoke(ctx, AdminSevenDayCheckInService_UpdateSevenDayCheckInConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminSevenDayCheckInServiceClient) ListSevenDayCheckInClaims(ctx context.Context, in *ListSevenDayCheckInClaimsRequest, opts ...grpc.CallOption) (*ListSevenDayCheckInClaimsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSevenDayCheckInClaimsResponse)
	err := c.cc.Invoke(ctx, AdminSevenDayCheckInService_ListSevenDayCheckInClaims_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminSevenDayCheckInServiceServer is the server API for AdminSevenDayCheckInService service.
// All implementations must embed UnimplementedAdminSevenDayCheckInServiceServer
// for forward compatibility.
//
// AdminSevenDayCheckInService 是后台活动管理访问七日签到配置和领取记录的唯一入口。
type AdminSevenDayCheckInServiceServer interface {
	GetSevenDayCheckInConfig(context.Context, *GetSevenDayCheckInConfigRequest) (*GetSevenDayCheckInConfigResponse, error)
	UpdateSevenDayCheckInConfig(context.Context, *UpdateSevenDayCheckInConfigRequest) (*UpdateSevenDayCheckInConfigResponse, error)
	ListSevenDayCheckInClaims(context.Context, *ListSevenDayCheckInClaimsRequest) (*ListSevenDayCheckInClaimsResponse, error)
	mustEmbedUnimplementedAdminSevenDayCheckInServiceServer()
}

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

func (UnimplementedAdminSevenDayCheckInServiceServer) GetSevenDayCheckInConfig(context.Context, *GetSevenDayCheckInConfigRequest) (*GetSevenDayCheckInConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSevenDayCheckInConfig not implemented")
}
func (UnimplementedAdminSevenDayCheckInServiceServer) UpdateSevenDayCheckInConfig(context.Context, *UpdateSevenDayCheckInConfigRequest) (*UpdateSevenDayCheckInConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateSevenDayCheckInConfig not implemented")
}
func (UnimplementedAdminSevenDayCheckInServiceServer) ListSevenDayCheckInClaims(context.Context, *ListSevenDayCheckInClaimsRequest) (*ListSevenDayCheckInClaimsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListSevenDayCheckInClaims not implemented")
}
func (UnimplementedAdminSevenDayCheckInServiceServer) mustEmbedUnimplementedAdminSevenDayCheckInServiceServer() {
}
func (UnimplementedAdminSevenDayCheckInServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminSevenDayCheckInServiceServer(s grpc.ServiceRegistrar, srv AdminSevenDayCheckInServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminSevenDayCheckInServiceServer 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(&AdminSevenDayCheckInService_ServiceDesc, srv)
}

func _AdminSevenDayCheckInService_GetSevenDayCheckInConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSevenDayCheckInConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminSevenDayCheckInServiceServer).GetSevenDayCheckInConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminSevenDayCheckInService_GetSevenDayCheckInConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminSevenDayCheckInServiceServer).GetSevenDayCheckInConfig(ctx, req.(*GetSevenDayCheckInConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminSevenDayCheckInService_UpdateSevenDayCheckInConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSevenDayCheckInConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminSevenDayCheckInServiceServer).UpdateSevenDayCheckInConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminSevenDayCheckInService_UpdateSevenDayCheckInConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminSevenDayCheckInServiceServer).UpdateSevenDayCheckInConfig(ctx, req.(*UpdateSevenDayCheckInConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminSevenDayCheckInService_ListSevenDayCheckInClaims_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSevenDayCheckInClaimsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminSevenDayCheckInServiceServer).ListSevenDayCheckInClaims(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminSevenDayCheckInService_ListSevenDayCheckInClaims_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminSevenDayCheckInServiceServer).ListSevenDayCheckInClaims(ctx, req.(*ListSevenDayCheckInClaimsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminSevenDayCheckInService_ServiceDesc is the grpc.ServiceDesc for AdminSevenDayCheckInService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminSevenDayCheckInService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminSevenDayCheckInService",
	HandlerType: (*AdminSevenDayCheckInServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetSevenDayCheckInConfig",
			Handler:    _AdminSevenDayCheckInService_GetSevenDayCheckInConfig_Handler,
		},
		{
			MethodName: "UpdateSevenDayCheckInConfig",
			Handler:    _AdminSevenDayCheckInService_UpdateSevenDayCheckInConfig_Handler,
		},
		{
			MethodName: "ListSevenDayCheckInClaims",
			Handler:    _AdminSevenDayCheckInService_ListSevenDayCheckInClaims_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminGrowthLevelService_ListLevelConfig_FullMethodName  = "/hyapp.activity.v1.AdminGrowthLevelService/ListLevelConfig"
	AdminGrowthLevelService_UpsertLevelTrack_FullMethodName = "/hyapp.activity.v1.AdminGrowthLevelService/UpsertLevelTrack"
	AdminGrowthLevelService_UpsertLevelRule_FullMethodName  = "/hyapp.activity.v1.AdminGrowthLevelService/UpsertLevelRule"
	AdminGrowthLevelService_UpsertLevelTier_FullMethodName  = "/hyapp.activity.v1.AdminGrowthLevelService/UpsertLevelTier"
)

// AdminGrowthLevelServiceClient is the client API for AdminGrowthLevelService 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.
//
// AdminGrowthLevelService 是后台等级配置访问 activity-service 的唯一入口。
type AdminGrowthLevelServiceClient interface {
	ListLevelConfig(ctx context.Context, in *ListLevelConfigRequest, opts ...grpc.CallOption) (*ListLevelConfigResponse, error)
	UpsertLevelTrack(ctx context.Context, in *UpsertLevelTrackRequest, opts ...grpc.CallOption) (*UpsertLevelTrackResponse, error)
	UpsertLevelRule(ctx context.Context, in *UpsertLevelRuleRequest, opts ...grpc.CallOption) (*UpsertLevelRuleResponse, error)
	UpsertLevelTier(ctx context.Context, in *UpsertLevelTierRequest, opts ...grpc.CallOption) (*UpsertLevelTierResponse, error)
}

type adminGrowthLevelServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminGrowthLevelServiceClient(cc grpc.ClientConnInterface) AdminGrowthLevelServiceClient {
	return &adminGrowthLevelServiceClient{cc}
}

func (c *adminGrowthLevelServiceClient) ListLevelConfig(ctx context.Context, in *ListLevelConfigRequest, opts ...grpc.CallOption) (*ListLevelConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListLevelConfigResponse)
	err := c.cc.Invoke(ctx, AdminGrowthLevelService_ListLevelConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminGrowthLevelServiceClient) UpsertLevelTrack(ctx context.Context, in *UpsertLevelTrackRequest, opts ...grpc.CallOption) (*UpsertLevelTrackResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertLevelTrackResponse)
	err := c.cc.Invoke(ctx, AdminGrowthLevelService_UpsertLevelTrack_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminGrowthLevelServiceClient) UpsertLevelRule(ctx context.Context, in *UpsertLevelRuleRequest, opts ...grpc.CallOption) (*UpsertLevelRuleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertLevelRuleResponse)
	err := c.cc.Invoke(ctx, AdminGrowthLevelService_UpsertLevelRule_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminGrowthLevelServiceClient) UpsertLevelTier(ctx context.Context, in *UpsertLevelTierRequest, opts ...grpc.CallOption) (*UpsertLevelTierResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertLevelTierResponse)
	err := c.cc.Invoke(ctx, AdminGrowthLevelService_UpsertLevelTier_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminGrowthLevelServiceServer is the server API for AdminGrowthLevelService service.
// All implementations must embed UnimplementedAdminGrowthLevelServiceServer
// for forward compatibility.
//
// AdminGrowthLevelService 是后台等级配置访问 activity-service 的唯一入口。
type AdminGrowthLevelServiceServer interface {
	ListLevelConfig(context.Context, *ListLevelConfigRequest) (*ListLevelConfigResponse, error)
	UpsertLevelTrack(context.Context, *UpsertLevelTrackRequest) (*UpsertLevelTrackResponse, error)
	UpsertLevelRule(context.Context, *UpsertLevelRuleRequest) (*UpsertLevelRuleResponse, error)
	UpsertLevelTier(context.Context, *UpsertLevelTierRequest) (*UpsertLevelTierResponse, error)
	mustEmbedUnimplementedAdminGrowthLevelServiceServer()
}

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

func (UnimplementedAdminGrowthLevelServiceServer) ListLevelConfig(context.Context, *ListLevelConfigRequest) (*ListLevelConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListLevelConfig not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) UpsertLevelTrack(context.Context, *UpsertLevelTrackRequest) (*UpsertLevelTrackResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertLevelTrack not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) UpsertLevelRule(context.Context, *UpsertLevelRuleRequest) (*UpsertLevelRuleResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertLevelRule not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) UpsertLevelTier(context.Context, *UpsertLevelTierRequest) (*UpsertLevelTierResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertLevelTier not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) mustEmbedUnimplementedAdminGrowthLevelServiceServer() {
}
func (UnimplementedAdminGrowthLevelServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminGrowthLevelServiceServer(s grpc.ServiceRegistrar, srv AdminGrowthLevelServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminGrowthLevelServiceServer 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(&AdminGrowthLevelService_ServiceDesc, srv)
}

func _AdminGrowthLevelService_ListLevelConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListLevelConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminGrowthLevelServiceServer).ListLevelConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminGrowthLevelService_ListLevelConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminGrowthLevelServiceServer).ListLevelConfig(ctx, req.(*ListLevelConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminGrowthLevelService_UpsertLevelTrack_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertLevelTrackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminGrowthLevelServiceServer).UpsertLevelTrack(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminGrowthLevelService_UpsertLevelTrack_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminGrowthLevelServiceServer).UpsertLevelTrack(ctx, req.(*UpsertLevelTrackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminGrowthLevelService_UpsertLevelRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertLevelRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminGrowthLevelServiceServer).UpsertLevelRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminGrowthLevelService_UpsertLevelRule_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminGrowthLevelServiceServer).UpsertLevelRule(ctx, req.(*UpsertLevelRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminGrowthLevelService_UpsertLevelTier_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertLevelTierRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminGrowthLevelServiceServer).UpsertLevelTier(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminGrowthLevelService_UpsertLevelTier_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminGrowthLevelServiceServer).UpsertLevelTier(ctx, req.(*UpsertLevelTierRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminGrowthLevelService_ServiceDesc is the grpc.ServiceDesc for AdminGrowthLevelService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminGrowthLevelService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminGrowthLevelService",
	HandlerType: (*AdminGrowthLevelServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListLevelConfig",
			Handler:    _AdminGrowthLevelService_ListLevelConfig_Handler,
		},
		{
			MethodName: "UpsertLevelTrack",
			Handler:    _AdminGrowthLevelService_UpsertLevelTrack_Handler,
		},
		{
			MethodName: "UpsertLevelRule",
			Handler:    _AdminGrowthLevelService_UpsertLevelRule_Handler,
		},
		{
			MethodName: "UpsertLevelTier",
			Handler:    _AdminGrowthLevelService_UpsertLevelTier_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminAchievementService_ListAchievementDefinitions_FullMethodName  = "/hyapp.activity.v1.AdminAchievementService/ListAchievementDefinitions"
	AdminAchievementService_UpsertAchievementDefinition_FullMethodName = "/hyapp.activity.v1.AdminAchievementService/UpsertAchievementDefinition"
)

// AdminAchievementServiceClient is the client API for AdminAchievementService 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.
//
// AdminAchievementService is the admin entry for achievement definitions.
type AdminAchievementServiceClient interface {
	ListAchievementDefinitions(ctx context.Context, in *ListAchievementsRequest, opts ...grpc.CallOption) (*ListAchievementsResponse, error)
	UpsertAchievementDefinition(ctx context.Context, in *UpsertAchievementDefinitionRequest, opts ...grpc.CallOption) (*UpsertAchievementDefinitionResponse, error)
}

type adminAchievementServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminAchievementServiceClient(cc grpc.ClientConnInterface) AdminAchievementServiceClient {
	return &adminAchievementServiceClient{cc}
}

func (c *adminAchievementServiceClient) ListAchievementDefinitions(ctx context.Context, in *ListAchievementsRequest, opts ...grpc.CallOption) (*ListAchievementsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAchievementsResponse)
	err := c.cc.Invoke(ctx, AdminAchievementService_ListAchievementDefinitions_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAchievementServiceClient) UpsertAchievementDefinition(ctx context.Context, in *UpsertAchievementDefinitionRequest, opts ...grpc.CallOption) (*UpsertAchievementDefinitionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertAchievementDefinitionResponse)
	err := c.cc.Invoke(ctx, AdminAchievementService_UpsertAchievementDefinition_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminAchievementServiceServer is the server API for AdminAchievementService service.
// All implementations must embed UnimplementedAdminAchievementServiceServer
// for forward compatibility.
//
// AdminAchievementService is the admin entry for achievement definitions.
type AdminAchievementServiceServer interface {
	ListAchievementDefinitions(context.Context, *ListAchievementsRequest) (*ListAchievementsResponse, error)
	UpsertAchievementDefinition(context.Context, *UpsertAchievementDefinitionRequest) (*UpsertAchievementDefinitionResponse, error)
	mustEmbedUnimplementedAdminAchievementServiceServer()
}

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

func (UnimplementedAdminAchievementServiceServer) ListAchievementDefinitions(context.Context, *ListAchievementsRequest) (*ListAchievementsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListAchievementDefinitions not implemented")
}
func (UnimplementedAdminAchievementServiceServer) UpsertAchievementDefinition(context.Context, *UpsertAchievementDefinitionRequest) (*UpsertAchievementDefinitionResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertAchievementDefinition not implemented")
}
func (UnimplementedAdminAchievementServiceServer) mustEmbedUnimplementedAdminAchievementServiceServer() {
}
func (UnimplementedAdminAchievementServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminAchievementServiceServer(s grpc.ServiceRegistrar, srv AdminAchievementServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminAchievementServiceServer 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(&AdminAchievementService_ServiceDesc, srv)
}

func _AdminAchievementService_ListAchievementDefinitions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAchievementsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAchievementServiceServer).ListAchievementDefinitions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAchievementService_ListAchievementDefinitions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAchievementServiceServer).ListAchievementDefinitions(ctx, req.(*ListAchievementsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAchievementService_UpsertAchievementDefinition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertAchievementDefinitionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAchievementServiceServer).UpsertAchievementDefinition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAchievementService_UpsertAchievementDefinition_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAchievementServiceServer).UpsertAchievementDefinition(ctx, req.(*UpsertAchievementDefinitionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminAchievementService_ServiceDesc is the grpc.ServiceDesc for AdminAchievementService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminAchievementService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminAchievementService",
	HandlerType: (*AdminAchievementServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListAchievementDefinitions",
			Handler:    _AdminAchievementService_ListAchievementDefinitions_Handler,
		},
		{
			MethodName: "UpsertAchievementDefinition",
			Handler:    _AdminAchievementService_UpsertAchievementDefinition_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminLuckyGiftService_GetLuckyGiftConfig_FullMethodName    = "/hyapp.activity.v1.AdminLuckyGiftService/GetLuckyGiftConfig"
	AdminLuckyGiftService_UpsertLuckyGiftConfig_FullMethodName = "/hyapp.activity.v1.AdminLuckyGiftService/UpsertLuckyGiftConfig"
	AdminLuckyGiftService_ListLuckyGiftConfigs_FullMethodName  = "/hyapp.activity.v1.AdminLuckyGiftService/ListLuckyGiftConfigs"
	AdminLuckyGiftService_ListLuckyGiftDraws_FullMethodName    = "/hyapp.activity.v1.AdminLuckyGiftService/ListLuckyGiftDraws"
)

// AdminLuckyGiftServiceClient is the client API for AdminLuckyGiftService 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.
//
// AdminLuckyGiftService is the admin entry for lucky gift rule versions and draw audit.
type AdminLuckyGiftServiceClient interface {
	GetLuckyGiftConfig(ctx context.Context, in *GetLuckyGiftConfigRequest, opts ...grpc.CallOption) (*GetLuckyGiftConfigResponse, error)
	UpsertLuckyGiftConfig(ctx context.Context, in *UpsertLuckyGiftConfigRequest, opts ...grpc.CallOption) (*UpsertLuckyGiftConfigResponse, error)
	ListLuckyGiftConfigs(ctx context.Context, in *ListLuckyGiftConfigsRequest, opts ...grpc.CallOption) (*ListLuckyGiftConfigsResponse, error)
	ListLuckyGiftDraws(ctx context.Context, in *ListLuckyGiftDrawsRequest, opts ...grpc.CallOption) (*ListLuckyGiftDrawsResponse, error)
}

type adminLuckyGiftServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminLuckyGiftServiceClient(cc grpc.ClientConnInterface) AdminLuckyGiftServiceClient {
	return &adminLuckyGiftServiceClient{cc}
}

func (c *adminLuckyGiftServiceClient) GetLuckyGiftConfig(ctx context.Context, in *GetLuckyGiftConfigRequest, opts ...grpc.CallOption) (*GetLuckyGiftConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetLuckyGiftConfigResponse)
	err := c.cc.Invoke(ctx, AdminLuckyGiftService_GetLuckyGiftConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminLuckyGiftServiceClient) UpsertLuckyGiftConfig(ctx context.Context, in *UpsertLuckyGiftConfigRequest, opts ...grpc.CallOption) (*UpsertLuckyGiftConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertLuckyGiftConfigResponse)
	err := c.cc.Invoke(ctx, AdminLuckyGiftService_UpsertLuckyGiftConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminLuckyGiftServiceClient) ListLuckyGiftConfigs(ctx context.Context, in *ListLuckyGiftConfigsRequest, opts ...grpc.CallOption) (*ListLuckyGiftConfigsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListLuckyGiftConfigsResponse)
	err := c.cc.Invoke(ctx, AdminLuckyGiftService_ListLuckyGiftConfigs_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminLuckyGiftServiceClient) ListLuckyGiftDraws(ctx context.Context, in *ListLuckyGiftDrawsRequest, opts ...grpc.CallOption) (*ListLuckyGiftDrawsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListLuckyGiftDrawsResponse)
	err := c.cc.Invoke(ctx, AdminLuckyGiftService_ListLuckyGiftDraws_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminLuckyGiftServiceServer is the server API for AdminLuckyGiftService service.
// All implementations must embed UnimplementedAdminLuckyGiftServiceServer
// for forward compatibility.
//
// AdminLuckyGiftService is the admin entry for lucky gift rule versions and draw audit.
type AdminLuckyGiftServiceServer interface {
	GetLuckyGiftConfig(context.Context, *GetLuckyGiftConfigRequest) (*GetLuckyGiftConfigResponse, error)
	UpsertLuckyGiftConfig(context.Context, *UpsertLuckyGiftConfigRequest) (*UpsertLuckyGiftConfigResponse, error)
	ListLuckyGiftConfigs(context.Context, *ListLuckyGiftConfigsRequest) (*ListLuckyGiftConfigsResponse, error)
	ListLuckyGiftDraws(context.Context, *ListLuckyGiftDrawsRequest) (*ListLuckyGiftDrawsResponse, error)
	mustEmbedUnimplementedAdminLuckyGiftServiceServer()
}

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

func (UnimplementedAdminLuckyGiftServiceServer) GetLuckyGiftConfig(context.Context, *GetLuckyGiftConfigRequest) (*GetLuckyGiftConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetLuckyGiftConfig not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) UpsertLuckyGiftConfig(context.Context, *UpsertLuckyGiftConfigRequest) (*UpsertLuckyGiftConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertLuckyGiftConfig not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) ListLuckyGiftConfigs(context.Context, *ListLuckyGiftConfigsRequest) (*ListLuckyGiftConfigsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListLuckyGiftConfigs not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) ListLuckyGiftDraws(context.Context, *ListLuckyGiftDrawsRequest) (*ListLuckyGiftDrawsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListLuckyGiftDraws not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) mustEmbedUnimplementedAdminLuckyGiftServiceServer() {}
func (UnimplementedAdminLuckyGiftServiceServer) testEmbeddedByValue()                               {}

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

func RegisterAdminLuckyGiftServiceServer(s grpc.ServiceRegistrar, srv AdminLuckyGiftServiceServer) {
	// If the following call panics, it indicates UnimplementedAdminLuckyGiftServiceServer 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(&AdminLuckyGiftService_ServiceDesc, srv)
}

func _AdminLuckyGiftService_GetLuckyGiftConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLuckyGiftConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminLuckyGiftServiceServer).GetLuckyGiftConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminLuckyGiftService_GetLuckyGiftConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminLuckyGiftServiceServer).GetLuckyGiftConfig(ctx, req.(*GetLuckyGiftConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminLuckyGiftService_UpsertLuckyGiftConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertLuckyGiftConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminLuckyGiftServiceServer).UpsertLuckyGiftConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminLuckyGiftService_UpsertLuckyGiftConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminLuckyGiftServiceServer).UpsertLuckyGiftConfig(ctx, req.(*UpsertLuckyGiftConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminLuckyGiftService_ListLuckyGiftConfigs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListLuckyGiftConfigsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminLuckyGiftServiceServer).ListLuckyGiftConfigs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminLuckyGiftService_ListLuckyGiftConfigs_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminLuckyGiftServiceServer).ListLuckyGiftConfigs(ctx, req.(*ListLuckyGiftConfigsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminLuckyGiftService_ListLuckyGiftDraws_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListLuckyGiftDrawsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminLuckyGiftServiceServer).ListLuckyGiftDraws(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminLuckyGiftService_ListLuckyGiftDraws_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminLuckyGiftServiceServer).ListLuckyGiftDraws(ctx, req.(*ListLuckyGiftDrawsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminLuckyGiftService_ServiceDesc is the grpc.ServiceDesc for AdminLuckyGiftService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminLuckyGiftService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminLuckyGiftService",
	HandlerType: (*AdminLuckyGiftServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetLuckyGiftConfig",
			Handler:    _AdminLuckyGiftService_GetLuckyGiftConfig_Handler,
		},
		{
			MethodName: "UpsertLuckyGiftConfig",
			Handler:    _AdminLuckyGiftService_UpsertLuckyGiftConfig_Handler,
		},
		{
			MethodName: "ListLuckyGiftConfigs",
			Handler:    _AdminLuckyGiftService_ListLuckyGiftConfigs_Handler,
		},
		{
			MethodName: "ListLuckyGiftDraws",
			Handler:    _AdminLuckyGiftService_ListLuckyGiftDraws_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}