// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v5.29.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.Errorf(codes.Unimplemented, "method PingActivity not implemented")
}
func (UnimplementedActivityServiceServer) GetActivityStatus(context.Context, *GetActivityStatusRequest) (*GetActivityStatusResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method ListMessageTabs not implemented")
}
func (UnimplementedMessageInboxServiceServer) ListInboxMessages(context.Context, *ListInboxMessagesRequest) (*ListInboxMessagesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListInboxMessages not implemented")
}
func (UnimplementedMessageInboxServiceServer) MarkInboxMessageRead(context.Context, *MarkInboxMessageReadRequest) (*MarkInboxMessageReadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MarkInboxMessageRead not implemented")
}
func (UnimplementedMessageInboxServiceServer) MarkInboxSectionRead(context.Context, *MarkInboxSectionReadRequest) (*MarkInboxSectionReadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MarkInboxSectionRead not implemented")
}
func (UnimplementedMessageInboxServiceServer) DeleteInboxMessage(context.Context, *DeleteInboxMessageRequest) (*DeleteInboxMessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteInboxMessage not implemented")
}
func (UnimplementedMessageInboxServiceServer) CreateInboxMessage(context.Context, *CreateInboxMessageRequest) (*CreateInboxMessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateInboxMessage not implemented")
}
func (UnimplementedMessageInboxServiceServer) CreateFanoutJob(context.Context, *CreateFanoutJobRequest) (*CreateFanoutJobResponse, error) {
	return nil, status.Errorf(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 pancis, 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"
)

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

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
}

// 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)
	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.Errorf(codes.Unimplemented, "method ProcessMessageFanoutBatch 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 pancis, 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)
}

// 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,
		},
	},
	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.Errorf(codes.Unimplemented, "method ListUserTasks not implemented")
}
func (UnimplementedTaskServiceServer) ClaimTaskReward(context.Context, *ClaimTaskRewardRequest) (*ClaimTaskRewardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClaimTaskReward not implemented")
}
func (UnimplementedTaskServiceServer) ConsumeTaskEvent(context.Context, *ConsumeTaskEventRequest) (*ConsumeTaskEventResponse, error) {
	return nil, status.Errorf(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 pancis, 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 (
	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.Errorf(codes.Unimplemented, "method EnsureBroadcastGroups not implemented")
}
func (UnimplementedBroadcastServiceServer) PublishRegionBroadcast(context.Context, *PublishRegionBroadcastRequest) (*PublishBroadcastResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublishRegionBroadcast not implemented")
}
func (UnimplementedBroadcastServiceServer) PublishGlobalBroadcast(context.Context, *PublishGlobalBroadcastRequest) (*PublishBroadcastResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PublishGlobalBroadcast not implemented")
}
func (UnimplementedBroadcastServiceServer) RemoveRegionBroadcastMember(context.Context, *RemoveRegionBroadcastMemberRequest) (*RemoveRegionBroadcastMemberResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveRegionBroadcastMember not implemented")
}
func (UnimplementedBroadcastServiceServer) ProcessBroadcastOutboxBatch(context.Context, *CronBatchRequest) (*ProcessBroadcastOutboxBatchResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method ListTaskDefinitions not implemented")
}
func (UnimplementedAdminTaskServiceServer) UpsertTaskDefinition(context.Context, *UpsertTaskDefinitionRequest) (*UpsertTaskDefinitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertTaskDefinition not implemented")
}
func (UnimplementedAdminTaskServiceServer) SetTaskDefinitionStatus(context.Context, *SetTaskDefinitionStatusRequest) (*SetTaskDefinitionStatusResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method GetRegistrationRewardEligibility not implemented")
}
func (UnimplementedRegistrationRewardServiceServer) IssueRegistrationReward(context.Context, *IssueRegistrationRewardRequest) (*IssueRegistrationRewardResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method GetRegistrationRewardConfig not implemented")
}
func (UnimplementedAdminRegistrationRewardServiceServer) UpdateRegistrationRewardConfig(context.Context, *UpdateRegistrationRewardConfigRequest) (*UpdateRegistrationRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRegistrationRewardConfig not implemented")
}
func (UnimplementedAdminRegistrationRewardServiceServer) ListRegistrationRewardClaims(context.Context, *ListRegistrationRewardClaimsRequest) (*ListRegistrationRewardClaimsResponse, error) {
	return nil, status.Errorf(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 pancis, 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",
}
