// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             v7.35.0
// 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 (
	MessageActionConfirmService_AcceptActionConfirm_FullMethodName            = "/hyapp.activity.v1.MessageActionConfirmService/AcceptActionConfirm"
	MessageActionConfirmService_RejectActionConfirm_FullMethodName            = "/hyapp.activity.v1.MessageActionConfirmService/RejectActionConfirm"
	MessageActionConfirmService_BatchGetActionConfirmStatus_FullMethodName    = "/hyapp.activity.v1.MessageActionConfirmService/BatchGetActionConfirmStatus"
	MessageActionConfirmService_ListConversationActionConfirms_FullMethodName = "/hyapp.activity.v1.MessageActionConfirmService/ListConversationActionConfirms"
)

// MessageActionConfirmServiceClient is the client API for MessageActionConfirmService 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.
//
// MessageActionConfirmService 拥有 IM 操作按钮的确认状态，业务执行仍回到 owner service。
type MessageActionConfirmServiceClient interface {
	AcceptActionConfirm(ctx context.Context, in *AcceptActionConfirmRequest, opts ...grpc.CallOption) (*AcceptActionConfirmResponse, error)
	RejectActionConfirm(ctx context.Context, in *RejectActionConfirmRequest, opts ...grpc.CallOption) (*RejectActionConfirmResponse, error)
	BatchGetActionConfirmStatus(ctx context.Context, in *BatchGetActionConfirmStatusRequest, opts ...grpc.CallOption) (*BatchGetActionConfirmStatusResponse, error)
	ListConversationActionConfirms(ctx context.Context, in *ListConversationActionConfirmsRequest, opts ...grpc.CallOption) (*ListConversationActionConfirmsResponse, error)
}

type messageActionConfirmServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewMessageActionConfirmServiceClient(cc grpc.ClientConnInterface) MessageActionConfirmServiceClient {
	return &messageActionConfirmServiceClient{cc}
}

func (c *messageActionConfirmServiceClient) AcceptActionConfirm(ctx context.Context, in *AcceptActionConfirmRequest, opts ...grpc.CallOption) (*AcceptActionConfirmResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AcceptActionConfirmResponse)
	err := c.cc.Invoke(ctx, MessageActionConfirmService_AcceptActionConfirm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageActionConfirmServiceClient) RejectActionConfirm(ctx context.Context, in *RejectActionConfirmRequest, opts ...grpc.CallOption) (*RejectActionConfirmResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RejectActionConfirmResponse)
	err := c.cc.Invoke(ctx, MessageActionConfirmService_RejectActionConfirm_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageActionConfirmServiceClient) BatchGetActionConfirmStatus(ctx context.Context, in *BatchGetActionConfirmStatusRequest, opts ...grpc.CallOption) (*BatchGetActionConfirmStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchGetActionConfirmStatusResponse)
	err := c.cc.Invoke(ctx, MessageActionConfirmService_BatchGetActionConfirmStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *messageActionConfirmServiceClient) ListConversationActionConfirms(ctx context.Context, in *ListConversationActionConfirmsRequest, opts ...grpc.CallOption) (*ListConversationActionConfirmsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListConversationActionConfirmsResponse)
	err := c.cc.Invoke(ctx, MessageActionConfirmService_ListConversationActionConfirms_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MessageActionConfirmServiceServer is the server API for MessageActionConfirmService service.
// All implementations must embed UnimplementedMessageActionConfirmServiceServer
// for forward compatibility.
//
// MessageActionConfirmService 拥有 IM 操作按钮的确认状态，业务执行仍回到 owner service。
type MessageActionConfirmServiceServer interface {
	AcceptActionConfirm(context.Context, *AcceptActionConfirmRequest) (*AcceptActionConfirmResponse, error)
	RejectActionConfirm(context.Context, *RejectActionConfirmRequest) (*RejectActionConfirmResponse, error)
	BatchGetActionConfirmStatus(context.Context, *BatchGetActionConfirmStatusRequest) (*BatchGetActionConfirmStatusResponse, error)
	ListConversationActionConfirms(context.Context, *ListConversationActionConfirmsRequest) (*ListConversationActionConfirmsResponse, error)
	mustEmbedUnimplementedMessageActionConfirmServiceServer()
}

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

func (UnimplementedMessageActionConfirmServiceServer) AcceptActionConfirm(context.Context, *AcceptActionConfirmRequest) (*AcceptActionConfirmResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AcceptActionConfirm not implemented")
}
func (UnimplementedMessageActionConfirmServiceServer) RejectActionConfirm(context.Context, *RejectActionConfirmRequest) (*RejectActionConfirmResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RejectActionConfirm not implemented")
}
func (UnimplementedMessageActionConfirmServiceServer) BatchGetActionConfirmStatus(context.Context, *BatchGetActionConfirmStatusRequest) (*BatchGetActionConfirmStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchGetActionConfirmStatus not implemented")
}
func (UnimplementedMessageActionConfirmServiceServer) ListConversationActionConfirms(context.Context, *ListConversationActionConfirmsRequest) (*ListConversationActionConfirmsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConversationActionConfirms not implemented")
}
func (UnimplementedMessageActionConfirmServiceServer) mustEmbedUnimplementedMessageActionConfirmServiceServer() {
}
func (UnimplementedMessageActionConfirmServiceServer) testEmbeddedByValue() {}

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

func RegisterMessageActionConfirmServiceServer(s grpc.ServiceRegistrar, srv MessageActionConfirmServiceServer) {
	// If the following call pancis, it indicates UnimplementedMessageActionConfirmServiceServer 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(&MessageActionConfirmService_ServiceDesc, srv)
}

func _MessageActionConfirmService_AcceptActionConfirm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AcceptActionConfirmRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageActionConfirmServiceServer).AcceptActionConfirm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageActionConfirmService_AcceptActionConfirm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageActionConfirmServiceServer).AcceptActionConfirm(ctx, req.(*AcceptActionConfirmRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageActionConfirmService_RejectActionConfirm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RejectActionConfirmRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageActionConfirmServiceServer).RejectActionConfirm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageActionConfirmService_RejectActionConfirm_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageActionConfirmServiceServer).RejectActionConfirm(ctx, req.(*RejectActionConfirmRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageActionConfirmService_BatchGetActionConfirmStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchGetActionConfirmStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageActionConfirmServiceServer).BatchGetActionConfirmStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageActionConfirmService_BatchGetActionConfirmStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageActionConfirmServiceServer).BatchGetActionConfirmStatus(ctx, req.(*BatchGetActionConfirmStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MessageActionConfirmService_ListConversationActionConfirms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListConversationActionConfirmsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MessageActionConfirmServiceServer).ListConversationActionConfirms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MessageActionConfirmService_ListConversationActionConfirms_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MessageActionConfirmServiceServer).ListConversationActionConfirms(ctx, req.(*ListConversationActionConfirmsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// MessageActionConfirmService_ServiceDesc is the grpc.ServiceDesc for MessageActionConfirmService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var MessageActionConfirmService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.MessageActionConfirmService",
	HandlerType: (*MessageActionConfirmServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AcceptActionConfirm",
			Handler:    _MessageActionConfirmService_AcceptActionConfirm_Handler,
		},
		{
			MethodName: "RejectActionConfirm",
			Handler:    _MessageActionConfirmService_RejectActionConfirm_Handler,
		},
		{
			MethodName: "BatchGetActionConfirmStatus",
			Handler:    _MessageActionConfirmService_BatchGetActionConfirmStatus_Handler,
		},
		{
			MethodName: "ListConversationActionConfirms",
			Handler:    _MessageActionConfirmService_ListConversationActionConfirms_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"
	ActivityCronService_ProcessRoomTurnoverRewardSettlementBatch_FullMethodName = "/hyapp.activity.v1.ActivityCronService/ProcessRoomTurnoverRewardSettlementBatch"
	ActivityCronService_ProcessWeeklyStarSettlementBatch_FullMethodName         = "/hyapp.activity.v1.ActivityCronService/ProcessWeeklyStarSettlementBatch"
	ActivityCronService_ProcessCPWeeklyRankSettlementBatch_FullMethodName       = "/hyapp.activity.v1.ActivityCronService/ProcessCPWeeklyRankSettlementBatch"
	ActivityCronService_ProcessAgencyOpeningSettlementBatch_FullMethodName      = "/hyapp.activity.v1.ActivityCronService/ProcessAgencyOpeningSettlementBatch"
)

// 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)
	ProcessRoomTurnoverRewardSettlementBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
	ProcessWeeklyStarSettlementBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
	ProcessCPWeeklyRankSettlementBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
	ProcessAgencyOpeningSettlementBatch(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
}

func (c *activityCronServiceClient) ProcessRoomTurnoverRewardSettlementBatch(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_ProcessRoomTurnoverRewardSettlementBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityCronServiceClient) ProcessWeeklyStarSettlementBatch(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_ProcessWeeklyStarSettlementBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityCronServiceClient) ProcessCPWeeklyRankSettlementBatch(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_ProcessCPWeeklyRankSettlementBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *activityCronServiceClient) ProcessAgencyOpeningSettlementBatch(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_ProcessAgencyOpeningSettlementBatch_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)
	ProcessRoomTurnoverRewardSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	ProcessWeeklyStarSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	ProcessCPWeeklyRankSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	ProcessAgencyOpeningSettlementBatch(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) ProcessLevelRewardBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessLevelRewardBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessAchievementRewardBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessAchievementRewardBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessRoomTurnoverRewardSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessRoomTurnoverRewardSettlementBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessWeeklyStarSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessWeeklyStarSettlementBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessCPWeeklyRankSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessCPWeeklyRankSettlementBatch not implemented")
}
func (UnimplementedActivityCronServiceServer) ProcessAgencyOpeningSettlementBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ProcessAgencyOpeningSettlementBatch 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)
}

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

func _ActivityCronService_ProcessRoomTurnoverRewardSettlementBatch_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).ProcessRoomTurnoverRewardSettlementBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessRoomTurnoverRewardSettlementBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessRoomTurnoverRewardSettlementBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityCronService_ProcessWeeklyStarSettlementBatch_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).ProcessWeeklyStarSettlementBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessWeeklyStarSettlementBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessWeeklyStarSettlementBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityCronService_ProcessCPWeeklyRankSettlementBatch_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).ProcessCPWeeklyRankSettlementBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessCPWeeklyRankSettlementBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessCPWeeklyRankSettlementBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ActivityCronService_ProcessAgencyOpeningSettlementBatch_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).ProcessAgencyOpeningSettlementBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ActivityCronService_ProcessAgencyOpeningSettlementBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ActivityCronServiceServer).ProcessAgencyOpeningSettlementBatch(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,
		},
		{
			MethodName: "ProcessRoomTurnoverRewardSettlementBatch",
			Handler:    _ActivityCronService_ProcessRoomTurnoverRewardSettlementBatch_Handler,
		},
		{
			MethodName: "ProcessWeeklyStarSettlementBatch",
			Handler:    _ActivityCronService_ProcessWeeklyStarSettlementBatch_Handler,
		},
		{
			MethodName: "ProcessCPWeeklyRankSettlementBatch",
			Handler:    _ActivityCronService_ProcessCPWeeklyRankSettlementBatch_Handler,
		},
		{
			MethodName: "ProcessAgencyOpeningSettlementBatch",
			Handler:    _ActivityCronService_ProcessAgencyOpeningSettlementBatch_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 (
	GrowthLevelService_GetMyLevelOverview_FullMethodName               = "/hyapp.activity.v1.GrowthLevelService/GetMyLevelOverview"
	GrowthLevelService_GetLevelTrack_FullMethodName                    = "/hyapp.activity.v1.GrowthLevelService/GetLevelTrack"
	GrowthLevelService_BatchGetUserLevelDisplayProfiles_FullMethodName = "/hyapp.activity.v1.GrowthLevelService/BatchGetUserLevelDisplayProfiles"
	GrowthLevelService_ListLevelRewards_FullMethodName                 = "/hyapp.activity.v1.GrowthLevelService/ListLevelRewards"
	GrowthLevelService_ConsumeLevelEvent_FullMethodName                = "/hyapp.activity.v1.GrowthLevelService/ConsumeLevelEvent"
	GrowthLevelService_SetUserLevel_FullMethodName                     = "/hyapp.activity.v1.GrowthLevelService/SetUserLevel"
	GrowthLevelService_IssueRegistrationLevelBadges_FullMethodName     = "/hyapp.activity.v1.GrowthLevelService/IssueRegistrationLevelBadges"
)

// 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)
	BatchGetUserLevelDisplayProfiles(ctx context.Context, in *BatchGetUserLevelDisplayProfilesRequest, opts ...grpc.CallOption) (*BatchGetUserLevelDisplayProfilesResponse, error)
	ListLevelRewards(ctx context.Context, in *ListLevelRewardsRequest, opts ...grpc.CallOption) (*ListLevelRewardsResponse, error)
	ConsumeLevelEvent(ctx context.Context, in *ConsumeLevelEventRequest, opts ...grpc.CallOption) (*ConsumeLevelEventResponse, error)
	SetUserLevel(ctx context.Context, in *SetUserLevelRequest, opts ...grpc.CallOption) (*SetUserLevelResponse, error)
	IssueRegistrationLevelBadges(ctx context.Context, in *IssueRegistrationLevelBadgesRequest, opts ...grpc.CallOption) (*IssueRegistrationLevelBadgesResponse, 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) BatchGetUserLevelDisplayProfiles(ctx context.Context, in *BatchGetUserLevelDisplayProfilesRequest, opts ...grpc.CallOption) (*BatchGetUserLevelDisplayProfilesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchGetUserLevelDisplayProfilesResponse)
	err := c.cc.Invoke(ctx, GrowthLevelService_BatchGetUserLevelDisplayProfiles_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
}

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

func (c *growthLevelServiceClient) IssueRegistrationLevelBadges(ctx context.Context, in *IssueRegistrationLevelBadgesRequest, opts ...grpc.CallOption) (*IssueRegistrationLevelBadgesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IssueRegistrationLevelBadgesResponse)
	err := c.cc.Invoke(ctx, GrowthLevelService_IssueRegistrationLevelBadges_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)
	BatchGetUserLevelDisplayProfiles(context.Context, *BatchGetUserLevelDisplayProfilesRequest) (*BatchGetUserLevelDisplayProfilesResponse, error)
	ListLevelRewards(context.Context, *ListLevelRewardsRequest) (*ListLevelRewardsResponse, error)
	ConsumeLevelEvent(context.Context, *ConsumeLevelEventRequest) (*ConsumeLevelEventResponse, error)
	SetUserLevel(context.Context, *SetUserLevelRequest) (*SetUserLevelResponse, error)
	IssueRegistrationLevelBadges(context.Context, *IssueRegistrationLevelBadgesRequest) (*IssueRegistrationLevelBadgesResponse, 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.Errorf(codes.Unimplemented, "method GetMyLevelOverview not implemented")
}
func (UnimplementedGrowthLevelServiceServer) GetLevelTrack(context.Context, *GetLevelTrackRequest) (*GetLevelTrackResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLevelTrack not implemented")
}
func (UnimplementedGrowthLevelServiceServer) BatchGetUserLevelDisplayProfiles(context.Context, *BatchGetUserLevelDisplayProfilesRequest) (*BatchGetUserLevelDisplayProfilesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchGetUserLevelDisplayProfiles not implemented")
}
func (UnimplementedGrowthLevelServiceServer) ListLevelRewards(context.Context, *ListLevelRewardsRequest) (*ListLevelRewardsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListLevelRewards not implemented")
}
func (UnimplementedGrowthLevelServiceServer) ConsumeLevelEvent(context.Context, *ConsumeLevelEventRequest) (*ConsumeLevelEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConsumeLevelEvent not implemented")
}
func (UnimplementedGrowthLevelServiceServer) SetUserLevel(context.Context, *SetUserLevelRequest) (*SetUserLevelResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetUserLevel not implemented")
}
func (UnimplementedGrowthLevelServiceServer) IssueRegistrationLevelBadges(context.Context, *IssueRegistrationLevelBadgesRequest) (*IssueRegistrationLevelBadgesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IssueRegistrationLevelBadges 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 pancis, 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_BatchGetUserLevelDisplayProfiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchGetUserLevelDisplayProfilesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrowthLevelServiceServer).BatchGetUserLevelDisplayProfiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GrowthLevelService_BatchGetUserLevelDisplayProfiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrowthLevelServiceServer).BatchGetUserLevelDisplayProfiles(ctx, req.(*BatchGetUserLevelDisplayProfilesRequest))
	}
	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)
}

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

func _GrowthLevelService_IssueRegistrationLevelBadges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IssueRegistrationLevelBadgesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrowthLevelServiceServer).IssueRegistrationLevelBadges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GrowthLevelService_IssueRegistrationLevelBadges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrowthLevelServiceServer).IssueRegistrationLevelBadges(ctx, req.(*IssueRegistrationLevelBadgesRequest))
	}
	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: "BatchGetUserLevelDisplayProfiles",
			Handler:    _GrowthLevelService_BatchGetUserLevelDisplayProfiles_Handler,
		},
		{
			MethodName: "ListLevelRewards",
			Handler:    _GrowthLevelService_ListLevelRewards_Handler,
		},
		{
			MethodName: "ConsumeLevelEvent",
			Handler:    _GrowthLevelService_ConsumeLevelEvent_Handler,
		},
		{
			MethodName: "SetUserLevel",
			Handler:    _GrowthLevelService_SetUserLevel_Handler,
		},
		{
			MethodName: "IssueRegistrationLevelBadges",
			Handler:    _GrowthLevelService_IssueRegistrationLevelBadges_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.Errorf(codes.Unimplemented, "method ListAchievements not implemented")
}
func (UnimplementedAchievementServiceServer) ConsumeAchievementEvent(context.Context, *ConsumeAchievementEventRequest) (*ConsumeAchievementEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConsumeAchievementEvent not implemented")
}
func (UnimplementedAchievementServiceServer) ListMyBadges(context.Context, *ListMyBadgesRequest) (*ListMyBadgesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListMyBadges not implemented")
}
func (UnimplementedAchievementServiceServer) SetBadgeDisplay(context.Context, *SetBadgeDisplayRequest) (*SetBadgeDisplayResponse, error) {
	return nil, status.Errorf(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 pancis, 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"
	LuckyGiftService_BatchExecuteLuckyGiftDraw_FullMethodName = "/hyapp.activity.v1.LuckyGiftService/BatchExecuteLuckyGiftDraw"
)

// 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)
	BatchExecuteLuckyGiftDraw(ctx context.Context, in *BatchExecuteLuckyGiftDrawRequest, opts ...grpc.CallOption) (*BatchExecuteLuckyGiftDrawResponse, 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
}

func (c *luckyGiftServiceClient) BatchExecuteLuckyGiftDraw(ctx context.Context, in *BatchExecuteLuckyGiftDrawRequest, opts ...grpc.CallOption) (*BatchExecuteLuckyGiftDrawResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(BatchExecuteLuckyGiftDrawResponse)
	err := c.cc.Invoke(ctx, LuckyGiftService_BatchExecuteLuckyGiftDraw_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)
	BatchExecuteLuckyGiftDraw(context.Context, *BatchExecuteLuckyGiftDrawRequest) (*BatchExecuteLuckyGiftDrawResponse, 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.Errorf(codes.Unimplemented, "method CheckLuckyGift not implemented")
}
func (UnimplementedLuckyGiftServiceServer) ExecuteLuckyGiftDraw(context.Context, *ExecuteLuckyGiftDrawRequest) (*ExecuteLuckyGiftDrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecuteLuckyGiftDraw not implemented")
}
func (UnimplementedLuckyGiftServiceServer) BatchExecuteLuckyGiftDraw(context.Context, *BatchExecuteLuckyGiftDrawRequest) (*BatchExecuteLuckyGiftDrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BatchExecuteLuckyGiftDraw 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 pancis, 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)
}

func _LuckyGiftService_BatchExecuteLuckyGiftDraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BatchExecuteLuckyGiftDrawRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LuckyGiftServiceServer).BatchExecuteLuckyGiftDraw(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: LuckyGiftService_BatchExecuteLuckyGiftDraw_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LuckyGiftServiceServer).BatchExecuteLuckyGiftDraw(ctx, req.(*BatchExecuteLuckyGiftDrawRequest))
	}
	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,
		},
		{
			MethodName: "BatchExecuteLuckyGiftDraw",
			Handler:    _LuckyGiftService_BatchExecuteLuckyGiftDraw_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	WheelService_ExecuteWheelDraw_FullMethodName = "/hyapp.activity.v1.WheelService/ExecuteWheelDraw"
)

// WheelServiceClient is the client API for WheelService 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.
//
// WheelService owns wheel draw decisions after wallet debit succeeds.
type WheelServiceClient interface {
	ExecuteWheelDraw(ctx context.Context, in *ExecuteWheelDrawRequest, opts ...grpc.CallOption) (*ExecuteWheelDrawResponse, error)
}

type wheelServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWheelServiceClient(cc grpc.ClientConnInterface) WheelServiceClient {
	return &wheelServiceClient{cc}
}

func (c *wheelServiceClient) ExecuteWheelDraw(ctx context.Context, in *ExecuteWheelDrawRequest, opts ...grpc.CallOption) (*ExecuteWheelDrawResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ExecuteWheelDrawResponse)
	err := c.cc.Invoke(ctx, WheelService_ExecuteWheelDraw_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WheelServiceServer is the server API for WheelService service.
// All implementations must embed UnimplementedWheelServiceServer
// for forward compatibility.
//
// WheelService owns wheel draw decisions after wallet debit succeeds.
type WheelServiceServer interface {
	ExecuteWheelDraw(context.Context, *ExecuteWheelDrawRequest) (*ExecuteWheelDrawResponse, error)
	mustEmbedUnimplementedWheelServiceServer()
}

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

func (UnimplementedWheelServiceServer) ExecuteWheelDraw(context.Context, *ExecuteWheelDrawRequest) (*ExecuteWheelDrawResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecuteWheelDraw not implemented")
}
func (UnimplementedWheelServiceServer) mustEmbedUnimplementedWheelServiceServer() {}
func (UnimplementedWheelServiceServer) testEmbeddedByValue()                      {}

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

func RegisterWheelServiceServer(s grpc.ServiceRegistrar, srv WheelServiceServer) {
	// If the following call pancis, it indicates UnimplementedWheelServiceServer 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(&WheelService_ServiceDesc, srv)
}

func _WheelService_ExecuteWheelDraw_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecuteWheelDrawRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WheelServiceServer).ExecuteWheelDraw(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: WheelService_ExecuteWheelDraw_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WheelServiceServer).ExecuteWheelDraw(ctx, req.(*ExecuteWheelDrawRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

const (
	RoomTurnoverRewardService_GetRoomTurnoverRewardStatus_FullMethodName = "/hyapp.activity.v1.RoomTurnoverRewardService/GetRoomTurnoverRewardStatus"
)

// RoomTurnoverRewardServiceClient is the client API for RoomTurnoverRewardService 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.
//
// RoomTurnoverRewardService owns App reads for the weekly room turnover reward activity.
type RoomTurnoverRewardServiceClient interface {
	GetRoomTurnoverRewardStatus(ctx context.Context, in *GetRoomTurnoverRewardStatusRequest, opts ...grpc.CallOption) (*GetRoomTurnoverRewardStatusResponse, error)
}

type roomTurnoverRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewRoomTurnoverRewardServiceClient(cc grpc.ClientConnInterface) RoomTurnoverRewardServiceClient {
	return &roomTurnoverRewardServiceClient{cc}
}

func (c *roomTurnoverRewardServiceClient) GetRoomTurnoverRewardStatus(ctx context.Context, in *GetRoomTurnoverRewardStatusRequest, opts ...grpc.CallOption) (*GetRoomTurnoverRewardStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetRoomTurnoverRewardStatusResponse)
	err := c.cc.Invoke(ctx, RoomTurnoverRewardService_GetRoomTurnoverRewardStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RoomTurnoverRewardServiceServer is the server API for RoomTurnoverRewardService service.
// All implementations must embed UnimplementedRoomTurnoverRewardServiceServer
// for forward compatibility.
//
// RoomTurnoverRewardService owns App reads for the weekly room turnover reward activity.
type RoomTurnoverRewardServiceServer interface {
	GetRoomTurnoverRewardStatus(context.Context, *GetRoomTurnoverRewardStatusRequest) (*GetRoomTurnoverRewardStatusResponse, error)
	mustEmbedUnimplementedRoomTurnoverRewardServiceServer()
}

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

func (UnimplementedRoomTurnoverRewardServiceServer) GetRoomTurnoverRewardStatus(context.Context, *GetRoomTurnoverRewardStatusRequest) (*GetRoomTurnoverRewardStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRoomTurnoverRewardStatus not implemented")
}
func (UnimplementedRoomTurnoverRewardServiceServer) mustEmbedUnimplementedRoomTurnoverRewardServiceServer() {
}
func (UnimplementedRoomTurnoverRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterRoomTurnoverRewardServiceServer(s grpc.ServiceRegistrar, srv RoomTurnoverRewardServiceServer) {
	// If the following call pancis, it indicates UnimplementedRoomTurnoverRewardServiceServer 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(&RoomTurnoverRewardService_ServiceDesc, srv)
}

func _RoomTurnoverRewardService_GetRoomTurnoverRewardStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoomTurnoverRewardStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoomTurnoverRewardServiceServer).GetRoomTurnoverRewardStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: RoomTurnoverRewardService_GetRoomTurnoverRewardStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoomTurnoverRewardServiceServer).GetRoomTurnoverRewardStatus(ctx, req.(*GetRoomTurnoverRewardStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

const (
	WeeklyStarService_GetWeeklyStarCurrent_FullMethodName      = "/hyapp.activity.v1.WeeklyStarService/GetWeeklyStarCurrent"
	WeeklyStarService_ListWeeklyStarLeaderboard_FullMethodName = "/hyapp.activity.v1.WeeklyStarService/ListWeeklyStarLeaderboard"
	WeeklyStarService_ListWeeklyStarHistory_FullMethodName     = "/hyapp.activity.v1.WeeklyStarService/ListWeeklyStarHistory"
)

// WeeklyStarServiceClient is the client API for WeeklyStarService 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.
//
// WeeklyStarService owns App reads for the weekly specified-gift score activity.
type WeeklyStarServiceClient interface {
	GetWeeklyStarCurrent(ctx context.Context, in *GetWeeklyStarCurrentRequest, opts ...grpc.CallOption) (*GetWeeklyStarCurrentResponse, error)
	ListWeeklyStarLeaderboard(ctx context.Context, in *ListWeeklyStarLeaderboardRequest, opts ...grpc.CallOption) (*ListWeeklyStarLeaderboardResponse, error)
	ListWeeklyStarHistory(ctx context.Context, in *ListWeeklyStarHistoryRequest, opts ...grpc.CallOption) (*ListWeeklyStarHistoryResponse, error)
}

type weeklyStarServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewWeeklyStarServiceClient(cc grpc.ClientConnInterface) WeeklyStarServiceClient {
	return &weeklyStarServiceClient{cc}
}

func (c *weeklyStarServiceClient) GetWeeklyStarCurrent(ctx context.Context, in *GetWeeklyStarCurrentRequest, opts ...grpc.CallOption) (*GetWeeklyStarCurrentResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWeeklyStarCurrentResponse)
	err := c.cc.Invoke(ctx, WeeklyStarService_GetWeeklyStarCurrent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *weeklyStarServiceClient) ListWeeklyStarLeaderboard(ctx context.Context, in *ListWeeklyStarLeaderboardRequest, opts ...grpc.CallOption) (*ListWeeklyStarLeaderboardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWeeklyStarLeaderboardResponse)
	err := c.cc.Invoke(ctx, WeeklyStarService_ListWeeklyStarLeaderboard_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *weeklyStarServiceClient) ListWeeklyStarHistory(ctx context.Context, in *ListWeeklyStarHistoryRequest, opts ...grpc.CallOption) (*ListWeeklyStarHistoryResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWeeklyStarHistoryResponse)
	err := c.cc.Invoke(ctx, WeeklyStarService_ListWeeklyStarHistory_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// WeeklyStarServiceServer is the server API for WeeklyStarService service.
// All implementations must embed UnimplementedWeeklyStarServiceServer
// for forward compatibility.
//
// WeeklyStarService owns App reads for the weekly specified-gift score activity.
type WeeklyStarServiceServer interface {
	GetWeeklyStarCurrent(context.Context, *GetWeeklyStarCurrentRequest) (*GetWeeklyStarCurrentResponse, error)
	ListWeeklyStarLeaderboard(context.Context, *ListWeeklyStarLeaderboardRequest) (*ListWeeklyStarLeaderboardResponse, error)
	ListWeeklyStarHistory(context.Context, *ListWeeklyStarHistoryRequest) (*ListWeeklyStarHistoryResponse, error)
	mustEmbedUnimplementedWeeklyStarServiceServer()
}

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

func (UnimplementedWeeklyStarServiceServer) GetWeeklyStarCurrent(context.Context, *GetWeeklyStarCurrentRequest) (*GetWeeklyStarCurrentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWeeklyStarCurrent not implemented")
}
func (UnimplementedWeeklyStarServiceServer) ListWeeklyStarLeaderboard(context.Context, *ListWeeklyStarLeaderboardRequest) (*ListWeeklyStarLeaderboardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWeeklyStarLeaderboard not implemented")
}
func (UnimplementedWeeklyStarServiceServer) ListWeeklyStarHistory(context.Context, *ListWeeklyStarHistoryRequest) (*ListWeeklyStarHistoryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWeeklyStarHistory not implemented")
}
func (UnimplementedWeeklyStarServiceServer) mustEmbedUnimplementedWeeklyStarServiceServer() {}
func (UnimplementedWeeklyStarServiceServer) testEmbeddedByValue()                           {}

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

func RegisterWeeklyStarServiceServer(s grpc.ServiceRegistrar, srv WeeklyStarServiceServer) {
	// If the following call pancis, it indicates UnimplementedWeeklyStarServiceServer 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(&WeeklyStarService_ServiceDesc, srv)
}

func _WeeklyStarService_GetWeeklyStarCurrent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWeeklyStarCurrentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WeeklyStarServiceServer).GetWeeklyStarCurrent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: WeeklyStarService_GetWeeklyStarCurrent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WeeklyStarServiceServer).GetWeeklyStarCurrent(ctx, req.(*GetWeeklyStarCurrentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WeeklyStarService_ListWeeklyStarLeaderboard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWeeklyStarLeaderboardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WeeklyStarServiceServer).ListWeeklyStarLeaderboard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: WeeklyStarService_ListWeeklyStarLeaderboard_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WeeklyStarServiceServer).ListWeeklyStarLeaderboard(ctx, req.(*ListWeeklyStarLeaderboardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _WeeklyStarService_ListWeeklyStarHistory_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWeeklyStarHistoryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(WeeklyStarServiceServer).ListWeeklyStarHistory(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: WeeklyStarService_ListWeeklyStarHistory_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(WeeklyStarServiceServer).ListWeeklyStarHistory(ctx, req.(*ListWeeklyStarHistoryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// WeeklyStarService_ServiceDesc is the grpc.ServiceDesc for WeeklyStarService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var WeeklyStarService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.WeeklyStarService",
	HandlerType: (*WeeklyStarServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetWeeklyStarCurrent",
			Handler:    _WeeklyStarService_GetWeeklyStarCurrent_Handler,
		},
		{
			MethodName: "ListWeeklyStarLeaderboard",
			Handler:    _WeeklyStarService_ListWeeklyStarLeaderboard_Handler,
		},
		{
			MethodName: "ListWeeklyStarHistory",
			Handler:    _WeeklyStarService_ListWeeklyStarHistory_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	CPWeeklyRankService_GetCPWeeklyRankStatus_FullMethodName = "/hyapp.activity.v1.CPWeeklyRankService/GetCPWeeklyRankStatus"
)

// CPWeeklyRankServiceClient is the client API for CPWeeklyRankService 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.
//
// CPWeeklyRankService owns H5 reads for CP weekly rank and reward config.
type CPWeeklyRankServiceClient interface {
	GetCPWeeklyRankStatus(ctx context.Context, in *GetCPWeeklyRankStatusRequest, opts ...grpc.CallOption) (*GetCPWeeklyRankStatusResponse, error)
}

type cPWeeklyRankServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCPWeeklyRankServiceClient(cc grpc.ClientConnInterface) CPWeeklyRankServiceClient {
	return &cPWeeklyRankServiceClient{cc}
}

func (c *cPWeeklyRankServiceClient) GetCPWeeklyRankStatus(ctx context.Context, in *GetCPWeeklyRankStatusRequest, opts ...grpc.CallOption) (*GetCPWeeklyRankStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetCPWeeklyRankStatusResponse)
	err := c.cc.Invoke(ctx, CPWeeklyRankService_GetCPWeeklyRankStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CPWeeklyRankServiceServer is the server API for CPWeeklyRankService service.
// All implementations must embed UnimplementedCPWeeklyRankServiceServer
// for forward compatibility.
//
// CPWeeklyRankService owns H5 reads for CP weekly rank and reward config.
type CPWeeklyRankServiceServer interface {
	GetCPWeeklyRankStatus(context.Context, *GetCPWeeklyRankStatusRequest) (*GetCPWeeklyRankStatusResponse, error)
	mustEmbedUnimplementedCPWeeklyRankServiceServer()
}

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

func (UnimplementedCPWeeklyRankServiceServer) GetCPWeeklyRankStatus(context.Context, *GetCPWeeklyRankStatusRequest) (*GetCPWeeklyRankStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCPWeeklyRankStatus not implemented")
}
func (UnimplementedCPWeeklyRankServiceServer) mustEmbedUnimplementedCPWeeklyRankServiceServer() {}
func (UnimplementedCPWeeklyRankServiceServer) testEmbeddedByValue()                             {}

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

func RegisterCPWeeklyRankServiceServer(s grpc.ServiceRegistrar, srv CPWeeklyRankServiceServer) {
	// If the following call pancis, it indicates UnimplementedCPWeeklyRankServiceServer 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(&CPWeeklyRankService_ServiceDesc, srv)
}

func _CPWeeklyRankService_GetCPWeeklyRankStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCPWeeklyRankStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CPWeeklyRankServiceServer).GetCPWeeklyRankStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CPWeeklyRankService_GetCPWeeklyRankStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CPWeeklyRankServiceServer).GetCPWeeklyRankStatus(ctx, req.(*GetCPWeeklyRankStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

const (
	AgencyOpeningService_GetAgencyOpeningStatus_FullMethodName       = "/hyapp.activity.v1.AgencyOpeningService/GetAgencyOpeningStatus"
	AgencyOpeningService_ApplyAgencyOpening_FullMethodName           = "/hyapp.activity.v1.AgencyOpeningService/ApplyAgencyOpening"
	AgencyOpeningService_ListAgencyOpeningLeaderboard_FullMethodName = "/hyapp.activity.v1.AgencyOpeningService/ListAgencyOpeningLeaderboard"
)

// AgencyOpeningServiceClient is the client API for AgencyOpeningService 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.
//
// AgencyOpeningService owns App/H5 reads and application writes for agency opening activity.
type AgencyOpeningServiceClient interface {
	GetAgencyOpeningStatus(ctx context.Context, in *GetAgencyOpeningStatusRequest, opts ...grpc.CallOption) (*GetAgencyOpeningStatusResponse, error)
	ApplyAgencyOpening(ctx context.Context, in *ApplyAgencyOpeningRequest, opts ...grpc.CallOption) (*ApplyAgencyOpeningResponse, error)
	ListAgencyOpeningLeaderboard(ctx context.Context, in *ListAgencyOpeningApplicationsRequest, opts ...grpc.CallOption) (*ListAgencyOpeningApplicationsResponse, error)
}

type agencyOpeningServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAgencyOpeningServiceClient(cc grpc.ClientConnInterface) AgencyOpeningServiceClient {
	return &agencyOpeningServiceClient{cc}
}

func (c *agencyOpeningServiceClient) GetAgencyOpeningStatus(ctx context.Context, in *GetAgencyOpeningStatusRequest, opts ...grpc.CallOption) (*GetAgencyOpeningStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetAgencyOpeningStatusResponse)
	err := c.cc.Invoke(ctx, AgencyOpeningService_GetAgencyOpeningStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agencyOpeningServiceClient) ApplyAgencyOpening(ctx context.Context, in *ApplyAgencyOpeningRequest, opts ...grpc.CallOption) (*ApplyAgencyOpeningResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ApplyAgencyOpeningResponse)
	err := c.cc.Invoke(ctx, AgencyOpeningService_ApplyAgencyOpening_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *agencyOpeningServiceClient) ListAgencyOpeningLeaderboard(ctx context.Context, in *ListAgencyOpeningApplicationsRequest, opts ...grpc.CallOption) (*ListAgencyOpeningApplicationsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAgencyOpeningApplicationsResponse)
	err := c.cc.Invoke(ctx, AgencyOpeningService_ListAgencyOpeningLeaderboard_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AgencyOpeningServiceServer is the server API for AgencyOpeningService service.
// All implementations must embed UnimplementedAgencyOpeningServiceServer
// for forward compatibility.
//
// AgencyOpeningService owns App/H5 reads and application writes for agency opening activity.
type AgencyOpeningServiceServer interface {
	GetAgencyOpeningStatus(context.Context, *GetAgencyOpeningStatusRequest) (*GetAgencyOpeningStatusResponse, error)
	ApplyAgencyOpening(context.Context, *ApplyAgencyOpeningRequest) (*ApplyAgencyOpeningResponse, error)
	ListAgencyOpeningLeaderboard(context.Context, *ListAgencyOpeningApplicationsRequest) (*ListAgencyOpeningApplicationsResponse, error)
	mustEmbedUnimplementedAgencyOpeningServiceServer()
}

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

func (UnimplementedAgencyOpeningServiceServer) GetAgencyOpeningStatus(context.Context, *GetAgencyOpeningStatusRequest) (*GetAgencyOpeningStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAgencyOpeningStatus not implemented")
}
func (UnimplementedAgencyOpeningServiceServer) ApplyAgencyOpening(context.Context, *ApplyAgencyOpeningRequest) (*ApplyAgencyOpeningResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyAgencyOpening not implemented")
}
func (UnimplementedAgencyOpeningServiceServer) ListAgencyOpeningLeaderboard(context.Context, *ListAgencyOpeningApplicationsRequest) (*ListAgencyOpeningApplicationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAgencyOpeningLeaderboard not implemented")
}
func (UnimplementedAgencyOpeningServiceServer) mustEmbedUnimplementedAgencyOpeningServiceServer() {}
func (UnimplementedAgencyOpeningServiceServer) testEmbeddedByValue()                              {}

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

func RegisterAgencyOpeningServiceServer(s grpc.ServiceRegistrar, srv AgencyOpeningServiceServer) {
	// If the following call pancis, it indicates UnimplementedAgencyOpeningServiceServer 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(&AgencyOpeningService_ServiceDesc, srv)
}

func _AgencyOpeningService_GetAgencyOpeningStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAgencyOpeningStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgencyOpeningServiceServer).GetAgencyOpeningStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AgencyOpeningService_GetAgencyOpeningStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgencyOpeningServiceServer).GetAgencyOpeningStatus(ctx, req.(*GetAgencyOpeningStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgencyOpeningService_ApplyAgencyOpening_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyAgencyOpeningRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgencyOpeningServiceServer).ApplyAgencyOpening(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AgencyOpeningService_ApplyAgencyOpening_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgencyOpeningServiceServer).ApplyAgencyOpening(ctx, req.(*ApplyAgencyOpeningRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AgencyOpeningService_ListAgencyOpeningLeaderboard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAgencyOpeningApplicationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AgencyOpeningServiceServer).ListAgencyOpeningLeaderboard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AgencyOpeningService_ListAgencyOpeningLeaderboard_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AgencyOpeningServiceServer).ListAgencyOpeningLeaderboard(ctx, req.(*ListAgencyOpeningApplicationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AgencyOpeningService_ServiceDesc is the grpc.ServiceDesc for AgencyOpeningService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AgencyOpeningService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AgencyOpeningService",
	HandlerType: (*AgencyOpeningServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetAgencyOpeningStatus",
			Handler:    _AgencyOpeningService_GetAgencyOpeningStatus_Handler,
		},
		{
			MethodName: "ApplyAgencyOpening",
			Handler:    _AgencyOpeningService_ApplyAgencyOpening_Handler,
		},
		{
			MethodName: "ListAgencyOpeningLeaderboard",
			Handler:    _AgencyOpeningService_ListAgencyOpeningLeaderboard_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",
}

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.Errorf(codes.Unimplemented, "method GetFirstRechargeRewardStatus not implemented")
}
func (UnimplementedFirstRechargeRewardServiceServer) ConsumeFirstRechargeReward(context.Context, *ConsumeFirstRechargeRewardRequest) (*ConsumeFirstRechargeRewardResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method GetFirstRechargeRewardConfig not implemented")
}
func (UnimplementedAdminFirstRechargeRewardServiceServer) UpdateFirstRechargeRewardConfig(context.Context, *UpdateFirstRechargeRewardConfigRequest) (*UpdateFirstRechargeRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateFirstRechargeRewardConfig not implemented")
}
func (UnimplementedAdminFirstRechargeRewardServiceServer) ListFirstRechargeRewardClaims(context.Context, *ListFirstRechargeRewardClaimsRequest) (*ListFirstRechargeRewardClaimsResponse, error) {
	return nil, status.Errorf(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 pancis, 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 (
	CumulativeRechargeRewardService_GetCumulativeRechargeRewardStatus_FullMethodName = "/hyapp.activity.v1.CumulativeRechargeRewardService/GetCumulativeRechargeRewardStatus"
	CumulativeRechargeRewardService_ConsumeCumulativeRechargeReward_FullMethodName   = "/hyapp.activity.v1.CumulativeRechargeRewardService/ConsumeCumulativeRechargeReward"
)

// CumulativeRechargeRewardServiceClient is the client API for CumulativeRechargeRewardService 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.
//
// CumulativeRechargeRewardService 拥有 App 累充奖励查询和 wallet 充值事实消费入口。
type CumulativeRechargeRewardServiceClient interface {
	GetCumulativeRechargeRewardStatus(ctx context.Context, in *GetCumulativeRechargeRewardStatusRequest, opts ...grpc.CallOption) (*GetCumulativeRechargeRewardStatusResponse, error)
	ConsumeCumulativeRechargeReward(ctx context.Context, in *ConsumeCumulativeRechargeRewardRequest, opts ...grpc.CallOption) (*ConsumeCumulativeRechargeRewardResponse, error)
}

type cumulativeRechargeRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewCumulativeRechargeRewardServiceClient(cc grpc.ClientConnInterface) CumulativeRechargeRewardServiceClient {
	return &cumulativeRechargeRewardServiceClient{cc}
}

func (c *cumulativeRechargeRewardServiceClient) GetCumulativeRechargeRewardStatus(ctx context.Context, in *GetCumulativeRechargeRewardStatusRequest, opts ...grpc.CallOption) (*GetCumulativeRechargeRewardStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetCumulativeRechargeRewardStatusResponse)
	err := c.cc.Invoke(ctx, CumulativeRechargeRewardService_GetCumulativeRechargeRewardStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *cumulativeRechargeRewardServiceClient) ConsumeCumulativeRechargeReward(ctx context.Context, in *ConsumeCumulativeRechargeRewardRequest, opts ...grpc.CallOption) (*ConsumeCumulativeRechargeRewardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ConsumeCumulativeRechargeRewardResponse)
	err := c.cc.Invoke(ctx, CumulativeRechargeRewardService_ConsumeCumulativeRechargeReward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// CumulativeRechargeRewardServiceServer is the server API for CumulativeRechargeRewardService service.
// All implementations must embed UnimplementedCumulativeRechargeRewardServiceServer
// for forward compatibility.
//
// CumulativeRechargeRewardService 拥有 App 累充奖励查询和 wallet 充值事实消费入口。
type CumulativeRechargeRewardServiceServer interface {
	GetCumulativeRechargeRewardStatus(context.Context, *GetCumulativeRechargeRewardStatusRequest) (*GetCumulativeRechargeRewardStatusResponse, error)
	ConsumeCumulativeRechargeReward(context.Context, *ConsumeCumulativeRechargeRewardRequest) (*ConsumeCumulativeRechargeRewardResponse, error)
	mustEmbedUnimplementedCumulativeRechargeRewardServiceServer()
}

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

func (UnimplementedCumulativeRechargeRewardServiceServer) GetCumulativeRechargeRewardStatus(context.Context, *GetCumulativeRechargeRewardStatusRequest) (*GetCumulativeRechargeRewardStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCumulativeRechargeRewardStatus not implemented")
}
func (UnimplementedCumulativeRechargeRewardServiceServer) ConsumeCumulativeRechargeReward(context.Context, *ConsumeCumulativeRechargeRewardRequest) (*ConsumeCumulativeRechargeRewardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConsumeCumulativeRechargeReward not implemented")
}
func (UnimplementedCumulativeRechargeRewardServiceServer) mustEmbedUnimplementedCumulativeRechargeRewardServiceServer() {
}
func (UnimplementedCumulativeRechargeRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterCumulativeRechargeRewardServiceServer(s grpc.ServiceRegistrar, srv CumulativeRechargeRewardServiceServer) {
	// If the following call pancis, it indicates UnimplementedCumulativeRechargeRewardServiceServer 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(&CumulativeRechargeRewardService_ServiceDesc, srv)
}

func _CumulativeRechargeRewardService_GetCumulativeRechargeRewardStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCumulativeRechargeRewardStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CumulativeRechargeRewardServiceServer).GetCumulativeRechargeRewardStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CumulativeRechargeRewardService_GetCumulativeRechargeRewardStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CumulativeRechargeRewardServiceServer).GetCumulativeRechargeRewardStatus(ctx, req.(*GetCumulativeRechargeRewardStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _CumulativeRechargeRewardService_ConsumeCumulativeRechargeReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumeCumulativeRechargeRewardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(CumulativeRechargeRewardServiceServer).ConsumeCumulativeRechargeReward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: CumulativeRechargeRewardService_ConsumeCumulativeRechargeReward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(CumulativeRechargeRewardServiceServer).ConsumeCumulativeRechargeReward(ctx, req.(*ConsumeCumulativeRechargeRewardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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

const (
	InviteActivityRewardService_GetInviteActivityRewardStatus_FullMethodName = "/hyapp.activity.v1.InviteActivityRewardService/GetInviteActivityRewardStatus"
	InviteActivityRewardService_ClaimInviteActivityReward_FullMethodName     = "/hyapp.activity.v1.InviteActivityRewardService/ClaimInviteActivityReward"
	InviteActivityRewardService_ListInviteActivityLeaderboard_FullMethodName = "/hyapp.activity.v1.InviteActivityRewardService/ListInviteActivityLeaderboard"
)

// InviteActivityRewardServiceClient is the client API for InviteActivityRewardService 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.
//
// InviteActivityRewardService 拥有 App 邀请活动状态、领奖和排行榜入口。
type InviteActivityRewardServiceClient interface {
	GetInviteActivityRewardStatus(ctx context.Context, in *GetInviteActivityRewardStatusRequest, opts ...grpc.CallOption) (*GetInviteActivityRewardStatusResponse, error)
	ClaimInviteActivityReward(ctx context.Context, in *ClaimInviteActivityRewardRequest, opts ...grpc.CallOption) (*ClaimInviteActivityRewardResponse, error)
	ListInviteActivityLeaderboard(ctx context.Context, in *ListInviteActivityLeaderboardRequest, opts ...grpc.CallOption) (*ListInviteActivityLeaderboardResponse, error)
}

type inviteActivityRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewInviteActivityRewardServiceClient(cc grpc.ClientConnInterface) InviteActivityRewardServiceClient {
	return &inviteActivityRewardServiceClient{cc}
}

func (c *inviteActivityRewardServiceClient) GetInviteActivityRewardStatus(ctx context.Context, in *GetInviteActivityRewardStatusRequest, opts ...grpc.CallOption) (*GetInviteActivityRewardStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetInviteActivityRewardStatusResponse)
	err := c.cc.Invoke(ctx, InviteActivityRewardService_GetInviteActivityRewardStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inviteActivityRewardServiceClient) ClaimInviteActivityReward(ctx context.Context, in *ClaimInviteActivityRewardRequest, opts ...grpc.CallOption) (*ClaimInviteActivityRewardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ClaimInviteActivityRewardResponse)
	err := c.cc.Invoke(ctx, InviteActivityRewardService_ClaimInviteActivityReward_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *inviteActivityRewardServiceClient) ListInviteActivityLeaderboard(ctx context.Context, in *ListInviteActivityLeaderboardRequest, opts ...grpc.CallOption) (*ListInviteActivityLeaderboardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListInviteActivityLeaderboardResponse)
	err := c.cc.Invoke(ctx, InviteActivityRewardService_ListInviteActivityLeaderboard_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// InviteActivityRewardServiceServer is the server API for InviteActivityRewardService service.
// All implementations must embed UnimplementedInviteActivityRewardServiceServer
// for forward compatibility.
//
// InviteActivityRewardService 拥有 App 邀请活动状态、领奖和排行榜入口。
type InviteActivityRewardServiceServer interface {
	GetInviteActivityRewardStatus(context.Context, *GetInviteActivityRewardStatusRequest) (*GetInviteActivityRewardStatusResponse, error)
	ClaimInviteActivityReward(context.Context, *ClaimInviteActivityRewardRequest) (*ClaimInviteActivityRewardResponse, error)
	ListInviteActivityLeaderboard(context.Context, *ListInviteActivityLeaderboardRequest) (*ListInviteActivityLeaderboardResponse, error)
	mustEmbedUnimplementedInviteActivityRewardServiceServer()
}

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

func (UnimplementedInviteActivityRewardServiceServer) GetInviteActivityRewardStatus(context.Context, *GetInviteActivityRewardStatusRequest) (*GetInviteActivityRewardStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInviteActivityRewardStatus not implemented")
}
func (UnimplementedInviteActivityRewardServiceServer) ClaimInviteActivityReward(context.Context, *ClaimInviteActivityRewardRequest) (*ClaimInviteActivityRewardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClaimInviteActivityReward not implemented")
}
func (UnimplementedInviteActivityRewardServiceServer) ListInviteActivityLeaderboard(context.Context, *ListInviteActivityLeaderboardRequest) (*ListInviteActivityLeaderboardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListInviteActivityLeaderboard not implemented")
}
func (UnimplementedInviteActivityRewardServiceServer) mustEmbedUnimplementedInviteActivityRewardServiceServer() {
}
func (UnimplementedInviteActivityRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterInviteActivityRewardServiceServer(s grpc.ServiceRegistrar, srv InviteActivityRewardServiceServer) {
	// If the following call pancis, it indicates UnimplementedInviteActivityRewardServiceServer 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(&InviteActivityRewardService_ServiceDesc, srv)
}

func _InviteActivityRewardService_GetInviteActivityRewardStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInviteActivityRewardStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InviteActivityRewardServiceServer).GetInviteActivityRewardStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InviteActivityRewardService_GetInviteActivityRewardStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InviteActivityRewardServiceServer).GetInviteActivityRewardStatus(ctx, req.(*GetInviteActivityRewardStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InviteActivityRewardService_ClaimInviteActivityReward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClaimInviteActivityRewardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InviteActivityRewardServiceServer).ClaimInviteActivityReward(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InviteActivityRewardService_ClaimInviteActivityReward_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InviteActivityRewardServiceServer).ClaimInviteActivityReward(ctx, req.(*ClaimInviteActivityRewardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _InviteActivityRewardService_ListInviteActivityLeaderboard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListInviteActivityLeaderboardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(InviteActivityRewardServiceServer).ListInviteActivityLeaderboard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: InviteActivityRewardService_ListInviteActivityLeaderboard_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(InviteActivityRewardServiceServer).ListInviteActivityLeaderboard(ctx, req.(*ListInviteActivityLeaderboardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// InviteActivityRewardService_ServiceDesc is the grpc.ServiceDesc for InviteActivityRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var InviteActivityRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.InviteActivityRewardService",
	HandlerType: (*InviteActivityRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInviteActivityRewardStatus",
			Handler:    _InviteActivityRewardService_GetInviteActivityRewardStatus_Handler,
		},
		{
			MethodName: "ClaimInviteActivityReward",
			Handler:    _InviteActivityRewardService_ClaimInviteActivityReward_Handler,
		},
		{
			MethodName: "ListInviteActivityLeaderboard",
			Handler:    _InviteActivityRewardService_ListInviteActivityLeaderboard_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminCumulativeRechargeRewardService_GetCumulativeRechargeRewardConfig_FullMethodName    = "/hyapp.activity.v1.AdminCumulativeRechargeRewardService/GetCumulativeRechargeRewardConfig"
	AdminCumulativeRechargeRewardService_UpdateCumulativeRechargeRewardConfig_FullMethodName = "/hyapp.activity.v1.AdminCumulativeRechargeRewardService/UpdateCumulativeRechargeRewardConfig"
	AdminCumulativeRechargeRewardService_ListCumulativeRechargeRewardGrants_FullMethodName   = "/hyapp.activity.v1.AdminCumulativeRechargeRewardService/ListCumulativeRechargeRewardGrants"
)

// AdminCumulativeRechargeRewardServiceClient is the client API for AdminCumulativeRechargeRewardService 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.
//
// AdminCumulativeRechargeRewardService 是后台活动管理访问累充奖励配置和发放记录的唯一入口。
type AdminCumulativeRechargeRewardServiceClient interface {
	GetCumulativeRechargeRewardConfig(ctx context.Context, in *GetCumulativeRechargeRewardConfigRequest, opts ...grpc.CallOption) (*GetCumulativeRechargeRewardConfigResponse, error)
	UpdateCumulativeRechargeRewardConfig(ctx context.Context, in *UpdateCumulativeRechargeRewardConfigRequest, opts ...grpc.CallOption) (*UpdateCumulativeRechargeRewardConfigResponse, error)
	ListCumulativeRechargeRewardGrants(ctx context.Context, in *ListCumulativeRechargeRewardGrantsRequest, opts ...grpc.CallOption) (*ListCumulativeRechargeRewardGrantsResponse, error)
}

type adminCumulativeRechargeRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminCumulativeRechargeRewardServiceClient(cc grpc.ClientConnInterface) AdminCumulativeRechargeRewardServiceClient {
	return &adminCumulativeRechargeRewardServiceClient{cc}
}

func (c *adminCumulativeRechargeRewardServiceClient) GetCumulativeRechargeRewardConfig(ctx context.Context, in *GetCumulativeRechargeRewardConfigRequest, opts ...grpc.CallOption) (*GetCumulativeRechargeRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetCumulativeRechargeRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminCumulativeRechargeRewardService_GetCumulativeRechargeRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminCumulativeRechargeRewardServiceClient) UpdateCumulativeRechargeRewardConfig(ctx context.Context, in *UpdateCumulativeRechargeRewardConfigRequest, opts ...grpc.CallOption) (*UpdateCumulativeRechargeRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateCumulativeRechargeRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminCumulativeRechargeRewardService_UpdateCumulativeRechargeRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminCumulativeRechargeRewardServiceClient) ListCumulativeRechargeRewardGrants(ctx context.Context, in *ListCumulativeRechargeRewardGrantsRequest, opts ...grpc.CallOption) (*ListCumulativeRechargeRewardGrantsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListCumulativeRechargeRewardGrantsResponse)
	err := c.cc.Invoke(ctx, AdminCumulativeRechargeRewardService_ListCumulativeRechargeRewardGrants_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminCumulativeRechargeRewardServiceServer is the server API for AdminCumulativeRechargeRewardService service.
// All implementations must embed UnimplementedAdminCumulativeRechargeRewardServiceServer
// for forward compatibility.
//
// AdminCumulativeRechargeRewardService 是后台活动管理访问累充奖励配置和发放记录的唯一入口。
type AdminCumulativeRechargeRewardServiceServer interface {
	GetCumulativeRechargeRewardConfig(context.Context, *GetCumulativeRechargeRewardConfigRequest) (*GetCumulativeRechargeRewardConfigResponse, error)
	UpdateCumulativeRechargeRewardConfig(context.Context, *UpdateCumulativeRechargeRewardConfigRequest) (*UpdateCumulativeRechargeRewardConfigResponse, error)
	ListCumulativeRechargeRewardGrants(context.Context, *ListCumulativeRechargeRewardGrantsRequest) (*ListCumulativeRechargeRewardGrantsResponse, error)
	mustEmbedUnimplementedAdminCumulativeRechargeRewardServiceServer()
}

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

func (UnimplementedAdminCumulativeRechargeRewardServiceServer) GetCumulativeRechargeRewardConfig(context.Context, *GetCumulativeRechargeRewardConfigRequest) (*GetCumulativeRechargeRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCumulativeRechargeRewardConfig not implemented")
}
func (UnimplementedAdminCumulativeRechargeRewardServiceServer) UpdateCumulativeRechargeRewardConfig(context.Context, *UpdateCumulativeRechargeRewardConfigRequest) (*UpdateCumulativeRechargeRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCumulativeRechargeRewardConfig not implemented")
}
func (UnimplementedAdminCumulativeRechargeRewardServiceServer) ListCumulativeRechargeRewardGrants(context.Context, *ListCumulativeRechargeRewardGrantsRequest) (*ListCumulativeRechargeRewardGrantsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCumulativeRechargeRewardGrants not implemented")
}
func (UnimplementedAdminCumulativeRechargeRewardServiceServer) mustEmbedUnimplementedAdminCumulativeRechargeRewardServiceServer() {
}
func (UnimplementedAdminCumulativeRechargeRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminCumulativeRechargeRewardServiceServer(s grpc.ServiceRegistrar, srv AdminCumulativeRechargeRewardServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminCumulativeRechargeRewardServiceServer 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(&AdminCumulativeRechargeRewardService_ServiceDesc, srv)
}

func _AdminCumulativeRechargeRewardService_GetCumulativeRechargeRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCumulativeRechargeRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminCumulativeRechargeRewardServiceServer).GetCumulativeRechargeRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminCumulativeRechargeRewardService_GetCumulativeRechargeRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminCumulativeRechargeRewardServiceServer).GetCumulativeRechargeRewardConfig(ctx, req.(*GetCumulativeRechargeRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminCumulativeRechargeRewardService_UpdateCumulativeRechargeRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateCumulativeRechargeRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminCumulativeRechargeRewardServiceServer).UpdateCumulativeRechargeRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminCumulativeRechargeRewardService_UpdateCumulativeRechargeRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminCumulativeRechargeRewardServiceServer).UpdateCumulativeRechargeRewardConfig(ctx, req.(*UpdateCumulativeRechargeRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminCumulativeRechargeRewardService_ListCumulativeRechargeRewardGrants_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCumulativeRechargeRewardGrantsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminCumulativeRechargeRewardServiceServer).ListCumulativeRechargeRewardGrants(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminCumulativeRechargeRewardService_ListCumulativeRechargeRewardGrants_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminCumulativeRechargeRewardServiceServer).ListCumulativeRechargeRewardGrants(ctx, req.(*ListCumulativeRechargeRewardGrantsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminCumulativeRechargeRewardService_ServiceDesc is the grpc.ServiceDesc for AdminCumulativeRechargeRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminCumulativeRechargeRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminCumulativeRechargeRewardService",
	HandlerType: (*AdminCumulativeRechargeRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCumulativeRechargeRewardConfig",
			Handler:    _AdminCumulativeRechargeRewardService_GetCumulativeRechargeRewardConfig_Handler,
		},
		{
			MethodName: "UpdateCumulativeRechargeRewardConfig",
			Handler:    _AdminCumulativeRechargeRewardService_UpdateCumulativeRechargeRewardConfig_Handler,
		},
		{
			MethodName: "ListCumulativeRechargeRewardGrants",
			Handler:    _AdminCumulativeRechargeRewardService_ListCumulativeRechargeRewardGrants_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminInviteActivityRewardService_GetInviteActivityRewardConfig_FullMethodName     = "/hyapp.activity.v1.AdminInviteActivityRewardService/GetInviteActivityRewardConfig"
	AdminInviteActivityRewardService_UpdateInviteActivityRewardConfig_FullMethodName  = "/hyapp.activity.v1.AdminInviteActivityRewardService/UpdateInviteActivityRewardConfig"
	AdminInviteActivityRewardService_ListInviteActivityRewardClaims_FullMethodName    = "/hyapp.activity.v1.AdminInviteActivityRewardService/ListInviteActivityRewardClaims"
	AdminInviteActivityRewardService_ListInviteActivityRewardSummaries_FullMethodName = "/hyapp.activity.v1.AdminInviteActivityRewardService/ListInviteActivityRewardSummaries"
)

// AdminInviteActivityRewardServiceClient is the client API for AdminInviteActivityRewardService 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.
//
// AdminInviteActivityRewardService 是后台活动管理访问邀请活动配置和领取记录的唯一入口。
type AdminInviteActivityRewardServiceClient interface {
	GetInviteActivityRewardConfig(ctx context.Context, in *GetInviteActivityRewardConfigRequest, opts ...grpc.CallOption) (*GetInviteActivityRewardConfigResponse, error)
	UpdateInviteActivityRewardConfig(ctx context.Context, in *UpdateInviteActivityRewardConfigRequest, opts ...grpc.CallOption) (*UpdateInviteActivityRewardConfigResponse, error)
	ListInviteActivityRewardClaims(ctx context.Context, in *ListInviteActivityRewardClaimsRequest, opts ...grpc.CallOption) (*ListInviteActivityRewardClaimsResponse, error)
	ListInviteActivityRewardSummaries(ctx context.Context, in *ListInviteActivityRewardSummariesRequest, opts ...grpc.CallOption) (*ListInviteActivityRewardSummariesResponse, error)
}

type adminInviteActivityRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminInviteActivityRewardServiceClient(cc grpc.ClientConnInterface) AdminInviteActivityRewardServiceClient {
	return &adminInviteActivityRewardServiceClient{cc}
}

func (c *adminInviteActivityRewardServiceClient) GetInviteActivityRewardConfig(ctx context.Context, in *GetInviteActivityRewardConfigRequest, opts ...grpc.CallOption) (*GetInviteActivityRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetInviteActivityRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminInviteActivityRewardService_GetInviteActivityRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminInviteActivityRewardServiceClient) UpdateInviteActivityRewardConfig(ctx context.Context, in *UpdateInviteActivityRewardConfigRequest, opts ...grpc.CallOption) (*UpdateInviteActivityRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateInviteActivityRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminInviteActivityRewardService_UpdateInviteActivityRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminInviteActivityRewardServiceClient) ListInviteActivityRewardClaims(ctx context.Context, in *ListInviteActivityRewardClaimsRequest, opts ...grpc.CallOption) (*ListInviteActivityRewardClaimsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListInviteActivityRewardClaimsResponse)
	err := c.cc.Invoke(ctx, AdminInviteActivityRewardService_ListInviteActivityRewardClaims_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminInviteActivityRewardServiceClient) ListInviteActivityRewardSummaries(ctx context.Context, in *ListInviteActivityRewardSummariesRequest, opts ...grpc.CallOption) (*ListInviteActivityRewardSummariesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListInviteActivityRewardSummariesResponse)
	err := c.cc.Invoke(ctx, AdminInviteActivityRewardService_ListInviteActivityRewardSummaries_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminInviteActivityRewardServiceServer is the server API for AdminInviteActivityRewardService service.
// All implementations must embed UnimplementedAdminInviteActivityRewardServiceServer
// for forward compatibility.
//
// AdminInviteActivityRewardService 是后台活动管理访问邀请活动配置和领取记录的唯一入口。
type AdminInviteActivityRewardServiceServer interface {
	GetInviteActivityRewardConfig(context.Context, *GetInviteActivityRewardConfigRequest) (*GetInviteActivityRewardConfigResponse, error)
	UpdateInviteActivityRewardConfig(context.Context, *UpdateInviteActivityRewardConfigRequest) (*UpdateInviteActivityRewardConfigResponse, error)
	ListInviteActivityRewardClaims(context.Context, *ListInviteActivityRewardClaimsRequest) (*ListInviteActivityRewardClaimsResponse, error)
	ListInviteActivityRewardSummaries(context.Context, *ListInviteActivityRewardSummariesRequest) (*ListInviteActivityRewardSummariesResponse, error)
	mustEmbedUnimplementedAdminInviteActivityRewardServiceServer()
}

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

func (UnimplementedAdminInviteActivityRewardServiceServer) GetInviteActivityRewardConfig(context.Context, *GetInviteActivityRewardConfigRequest) (*GetInviteActivityRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInviteActivityRewardConfig not implemented")
}
func (UnimplementedAdminInviteActivityRewardServiceServer) UpdateInviteActivityRewardConfig(context.Context, *UpdateInviteActivityRewardConfigRequest) (*UpdateInviteActivityRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateInviteActivityRewardConfig not implemented")
}
func (UnimplementedAdminInviteActivityRewardServiceServer) ListInviteActivityRewardClaims(context.Context, *ListInviteActivityRewardClaimsRequest) (*ListInviteActivityRewardClaimsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListInviteActivityRewardClaims not implemented")
}
func (UnimplementedAdminInviteActivityRewardServiceServer) ListInviteActivityRewardSummaries(context.Context, *ListInviteActivityRewardSummariesRequest) (*ListInviteActivityRewardSummariesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListInviteActivityRewardSummaries not implemented")
}
func (UnimplementedAdminInviteActivityRewardServiceServer) mustEmbedUnimplementedAdminInviteActivityRewardServiceServer() {
}
func (UnimplementedAdminInviteActivityRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminInviteActivityRewardServiceServer(s grpc.ServiceRegistrar, srv AdminInviteActivityRewardServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminInviteActivityRewardServiceServer 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(&AdminInviteActivityRewardService_ServiceDesc, srv)
}

func _AdminInviteActivityRewardService_GetInviteActivityRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInviteActivityRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminInviteActivityRewardServiceServer).GetInviteActivityRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminInviteActivityRewardService_GetInviteActivityRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminInviteActivityRewardServiceServer).GetInviteActivityRewardConfig(ctx, req.(*GetInviteActivityRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminInviteActivityRewardService_UpdateInviteActivityRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateInviteActivityRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminInviteActivityRewardServiceServer).UpdateInviteActivityRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminInviteActivityRewardService_UpdateInviteActivityRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminInviteActivityRewardServiceServer).UpdateInviteActivityRewardConfig(ctx, req.(*UpdateInviteActivityRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminInviteActivityRewardService_ListInviteActivityRewardClaims_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListInviteActivityRewardClaimsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminInviteActivityRewardServiceServer).ListInviteActivityRewardClaims(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminInviteActivityRewardService_ListInviteActivityRewardClaims_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminInviteActivityRewardServiceServer).ListInviteActivityRewardClaims(ctx, req.(*ListInviteActivityRewardClaimsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminInviteActivityRewardService_ListInviteActivityRewardSummaries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListInviteActivityRewardSummariesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminInviteActivityRewardServiceServer).ListInviteActivityRewardSummaries(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminInviteActivityRewardService_ListInviteActivityRewardSummaries_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminInviteActivityRewardServiceServer).ListInviteActivityRewardSummaries(ctx, req.(*ListInviteActivityRewardSummariesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminInviteActivityRewardService_ServiceDesc is the grpc.ServiceDesc for AdminInviteActivityRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminInviteActivityRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminInviteActivityRewardService",
	HandlerType: (*AdminInviteActivityRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetInviteActivityRewardConfig",
			Handler:    _AdminInviteActivityRewardService_GetInviteActivityRewardConfig_Handler,
		},
		{
			MethodName: "UpdateInviteActivityRewardConfig",
			Handler:    _AdminInviteActivityRewardService_UpdateInviteActivityRewardConfig_Handler,
		},
		{
			MethodName: "ListInviteActivityRewardClaims",
			Handler:    _AdminInviteActivityRewardService_ListInviteActivityRewardClaims_Handler,
		},
		{
			MethodName: "ListInviteActivityRewardSummaries",
			Handler:    _AdminInviteActivityRewardService_ListInviteActivityRewardSummaries_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminRoomTurnoverRewardService_GetRoomTurnoverRewardConfig_FullMethodName       = "/hyapp.activity.v1.AdminRoomTurnoverRewardService/GetRoomTurnoverRewardConfig"
	AdminRoomTurnoverRewardService_UpdateRoomTurnoverRewardConfig_FullMethodName    = "/hyapp.activity.v1.AdminRoomTurnoverRewardService/UpdateRoomTurnoverRewardConfig"
	AdminRoomTurnoverRewardService_ListRoomTurnoverRewardSettlements_FullMethodName = "/hyapp.activity.v1.AdminRoomTurnoverRewardService/ListRoomTurnoverRewardSettlements"
	AdminRoomTurnoverRewardService_RetryRoomTurnoverRewardSettlement_FullMethodName = "/hyapp.activity.v1.AdminRoomTurnoverRewardService/RetryRoomTurnoverRewardSettlement"
)

// AdminRoomTurnoverRewardServiceClient is the client API for AdminRoomTurnoverRewardService 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.
//
// AdminRoomTurnoverRewardService 是后台活动管理访问房间流水奖励配置和结算记录的唯一入口。
type AdminRoomTurnoverRewardServiceClient interface {
	GetRoomTurnoverRewardConfig(ctx context.Context, in *GetRoomTurnoverRewardConfigRequest, opts ...grpc.CallOption) (*GetRoomTurnoverRewardConfigResponse, error)
	UpdateRoomTurnoverRewardConfig(ctx context.Context, in *UpdateRoomTurnoverRewardConfigRequest, opts ...grpc.CallOption) (*UpdateRoomTurnoverRewardConfigResponse, error)
	ListRoomTurnoverRewardSettlements(ctx context.Context, in *ListRoomTurnoverRewardSettlementsRequest, opts ...grpc.CallOption) (*ListRoomTurnoverRewardSettlementsResponse, error)
	RetryRoomTurnoverRewardSettlement(ctx context.Context, in *RetryRoomTurnoverRewardSettlementRequest, opts ...grpc.CallOption) (*RetryRoomTurnoverRewardSettlementResponse, error)
}

type adminRoomTurnoverRewardServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminRoomTurnoverRewardServiceClient(cc grpc.ClientConnInterface) AdminRoomTurnoverRewardServiceClient {
	return &adminRoomTurnoverRewardServiceClient{cc}
}

func (c *adminRoomTurnoverRewardServiceClient) GetRoomTurnoverRewardConfig(ctx context.Context, in *GetRoomTurnoverRewardConfigRequest, opts ...grpc.CallOption) (*GetRoomTurnoverRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetRoomTurnoverRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminRoomTurnoverRewardService_GetRoomTurnoverRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminRoomTurnoverRewardServiceClient) UpdateRoomTurnoverRewardConfig(ctx context.Context, in *UpdateRoomTurnoverRewardConfigRequest, opts ...grpc.CallOption) (*UpdateRoomTurnoverRewardConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateRoomTurnoverRewardConfigResponse)
	err := c.cc.Invoke(ctx, AdminRoomTurnoverRewardService_UpdateRoomTurnoverRewardConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminRoomTurnoverRewardServiceClient) ListRoomTurnoverRewardSettlements(ctx context.Context, in *ListRoomTurnoverRewardSettlementsRequest, opts ...grpc.CallOption) (*ListRoomTurnoverRewardSettlementsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListRoomTurnoverRewardSettlementsResponse)
	err := c.cc.Invoke(ctx, AdminRoomTurnoverRewardService_ListRoomTurnoverRewardSettlements_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminRoomTurnoverRewardServiceClient) RetryRoomTurnoverRewardSettlement(ctx context.Context, in *RetryRoomTurnoverRewardSettlementRequest, opts ...grpc.CallOption) (*RetryRoomTurnoverRewardSettlementResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RetryRoomTurnoverRewardSettlementResponse)
	err := c.cc.Invoke(ctx, AdminRoomTurnoverRewardService_RetryRoomTurnoverRewardSettlement_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminRoomTurnoverRewardServiceServer is the server API for AdminRoomTurnoverRewardService service.
// All implementations must embed UnimplementedAdminRoomTurnoverRewardServiceServer
// for forward compatibility.
//
// AdminRoomTurnoverRewardService 是后台活动管理访问房间流水奖励配置和结算记录的唯一入口。
type AdminRoomTurnoverRewardServiceServer interface {
	GetRoomTurnoverRewardConfig(context.Context, *GetRoomTurnoverRewardConfigRequest) (*GetRoomTurnoverRewardConfigResponse, error)
	UpdateRoomTurnoverRewardConfig(context.Context, *UpdateRoomTurnoverRewardConfigRequest) (*UpdateRoomTurnoverRewardConfigResponse, error)
	ListRoomTurnoverRewardSettlements(context.Context, *ListRoomTurnoverRewardSettlementsRequest) (*ListRoomTurnoverRewardSettlementsResponse, error)
	RetryRoomTurnoverRewardSettlement(context.Context, *RetryRoomTurnoverRewardSettlementRequest) (*RetryRoomTurnoverRewardSettlementResponse, error)
	mustEmbedUnimplementedAdminRoomTurnoverRewardServiceServer()
}

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

func (UnimplementedAdminRoomTurnoverRewardServiceServer) GetRoomTurnoverRewardConfig(context.Context, *GetRoomTurnoverRewardConfigRequest) (*GetRoomTurnoverRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRoomTurnoverRewardConfig not implemented")
}
func (UnimplementedAdminRoomTurnoverRewardServiceServer) UpdateRoomTurnoverRewardConfig(context.Context, *UpdateRoomTurnoverRewardConfigRequest) (*UpdateRoomTurnoverRewardConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateRoomTurnoverRewardConfig not implemented")
}
func (UnimplementedAdminRoomTurnoverRewardServiceServer) ListRoomTurnoverRewardSettlements(context.Context, *ListRoomTurnoverRewardSettlementsRequest) (*ListRoomTurnoverRewardSettlementsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRoomTurnoverRewardSettlements not implemented")
}
func (UnimplementedAdminRoomTurnoverRewardServiceServer) RetryRoomTurnoverRewardSettlement(context.Context, *RetryRoomTurnoverRewardSettlementRequest) (*RetryRoomTurnoverRewardSettlementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RetryRoomTurnoverRewardSettlement not implemented")
}
func (UnimplementedAdminRoomTurnoverRewardServiceServer) mustEmbedUnimplementedAdminRoomTurnoverRewardServiceServer() {
}
func (UnimplementedAdminRoomTurnoverRewardServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminRoomTurnoverRewardServiceServer(s grpc.ServiceRegistrar, srv AdminRoomTurnoverRewardServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminRoomTurnoverRewardServiceServer 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(&AdminRoomTurnoverRewardService_ServiceDesc, srv)
}

func _AdminRoomTurnoverRewardService_GetRoomTurnoverRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoomTurnoverRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRoomTurnoverRewardServiceServer).GetRoomTurnoverRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRoomTurnoverRewardService_GetRoomTurnoverRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRoomTurnoverRewardServiceServer).GetRoomTurnoverRewardConfig(ctx, req.(*GetRoomTurnoverRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminRoomTurnoverRewardService_UpdateRoomTurnoverRewardConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRoomTurnoverRewardConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRoomTurnoverRewardServiceServer).UpdateRoomTurnoverRewardConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRoomTurnoverRewardService_UpdateRoomTurnoverRewardConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRoomTurnoverRewardServiceServer).UpdateRoomTurnoverRewardConfig(ctx, req.(*UpdateRoomTurnoverRewardConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminRoomTurnoverRewardService_ListRoomTurnoverRewardSettlements_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRoomTurnoverRewardSettlementsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRoomTurnoverRewardServiceServer).ListRoomTurnoverRewardSettlements(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRoomTurnoverRewardService_ListRoomTurnoverRewardSettlements_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRoomTurnoverRewardServiceServer).ListRoomTurnoverRewardSettlements(ctx, req.(*ListRoomTurnoverRewardSettlementsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminRoomTurnoverRewardService_RetryRoomTurnoverRewardSettlement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RetryRoomTurnoverRewardSettlementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminRoomTurnoverRewardServiceServer).RetryRoomTurnoverRewardSettlement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminRoomTurnoverRewardService_RetryRoomTurnoverRewardSettlement_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminRoomTurnoverRewardServiceServer).RetryRoomTurnoverRewardSettlement(ctx, req.(*RetryRoomTurnoverRewardSettlementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminRoomTurnoverRewardService_ServiceDesc is the grpc.ServiceDesc for AdminRoomTurnoverRewardService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminRoomTurnoverRewardService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminRoomTurnoverRewardService",
	HandlerType: (*AdminRoomTurnoverRewardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetRoomTurnoverRewardConfig",
			Handler:    _AdminRoomTurnoverRewardService_GetRoomTurnoverRewardConfig_Handler,
		},
		{
			MethodName: "UpdateRoomTurnoverRewardConfig",
			Handler:    _AdminRoomTurnoverRewardService_UpdateRoomTurnoverRewardConfig_Handler,
		},
		{
			MethodName: "ListRoomTurnoverRewardSettlements",
			Handler:    _AdminRoomTurnoverRewardService_ListRoomTurnoverRewardSettlements_Handler,
		},
		{
			MethodName: "RetryRoomTurnoverRewardSettlement",
			Handler:    _AdminRoomTurnoverRewardService_RetryRoomTurnoverRewardSettlement_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminWeeklyStarService_ListWeeklyStarCycles_FullMethodName      = "/hyapp.activity.v1.AdminWeeklyStarService/ListWeeklyStarCycles"
	AdminWeeklyStarService_CreateWeeklyStarCycle_FullMethodName     = "/hyapp.activity.v1.AdminWeeklyStarService/CreateWeeklyStarCycle"
	AdminWeeklyStarService_GetWeeklyStarCycle_FullMethodName        = "/hyapp.activity.v1.AdminWeeklyStarService/GetWeeklyStarCycle"
	AdminWeeklyStarService_UpdateWeeklyStarCycle_FullMethodName     = "/hyapp.activity.v1.AdminWeeklyStarService/UpdateWeeklyStarCycle"
	AdminWeeklyStarService_SetWeeklyStarCycleStatus_FullMethodName  = "/hyapp.activity.v1.AdminWeeklyStarService/SetWeeklyStarCycleStatus"
	AdminWeeklyStarService_ListWeeklyStarLeaderboard_FullMethodName = "/hyapp.activity.v1.AdminWeeklyStarService/ListWeeklyStarLeaderboard"
	AdminWeeklyStarService_ListWeeklyStarSettlements_FullMethodName = "/hyapp.activity.v1.AdminWeeklyStarService/ListWeeklyStarSettlements"
)

// AdminWeeklyStarServiceClient is the client API for AdminWeeklyStarService 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.
//
// AdminWeeklyStarService 是后台活动管理访问周星周期、榜单和结算结果的唯一入口。
type AdminWeeklyStarServiceClient interface {
	ListWeeklyStarCycles(ctx context.Context, in *ListWeeklyStarCyclesRequest, opts ...grpc.CallOption) (*ListWeeklyStarCyclesResponse, error)
	CreateWeeklyStarCycle(ctx context.Context, in *UpsertWeeklyStarCycleRequest, opts ...grpc.CallOption) (*UpsertWeeklyStarCycleResponse, error)
	GetWeeklyStarCycle(ctx context.Context, in *GetWeeklyStarCycleRequest, opts ...grpc.CallOption) (*GetWeeklyStarCycleResponse, error)
	UpdateWeeklyStarCycle(ctx context.Context, in *UpsertWeeklyStarCycleRequest, opts ...grpc.CallOption) (*UpsertWeeklyStarCycleResponse, error)
	SetWeeklyStarCycleStatus(ctx context.Context, in *SetWeeklyStarCycleStatusRequest, opts ...grpc.CallOption) (*SetWeeklyStarCycleStatusResponse, error)
	ListWeeklyStarLeaderboard(ctx context.Context, in *ListWeeklyStarLeaderboardRequest, opts ...grpc.CallOption) (*ListWeeklyStarLeaderboardResponse, error)
	ListWeeklyStarSettlements(ctx context.Context, in *ListWeeklyStarSettlementsRequest, opts ...grpc.CallOption) (*ListWeeklyStarSettlementsResponse, error)
}

type adminWeeklyStarServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminWeeklyStarServiceClient(cc grpc.ClientConnInterface) AdminWeeklyStarServiceClient {
	return &adminWeeklyStarServiceClient{cc}
}

func (c *adminWeeklyStarServiceClient) ListWeeklyStarCycles(ctx context.Context, in *ListWeeklyStarCyclesRequest, opts ...grpc.CallOption) (*ListWeeklyStarCyclesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWeeklyStarCyclesResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_ListWeeklyStarCycles_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWeeklyStarServiceClient) CreateWeeklyStarCycle(ctx context.Context, in *UpsertWeeklyStarCycleRequest, opts ...grpc.CallOption) (*UpsertWeeklyStarCycleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertWeeklyStarCycleResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_CreateWeeklyStarCycle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWeeklyStarServiceClient) GetWeeklyStarCycle(ctx context.Context, in *GetWeeklyStarCycleRequest, opts ...grpc.CallOption) (*GetWeeklyStarCycleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWeeklyStarCycleResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_GetWeeklyStarCycle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWeeklyStarServiceClient) UpdateWeeklyStarCycle(ctx context.Context, in *UpsertWeeklyStarCycleRequest, opts ...grpc.CallOption) (*UpsertWeeklyStarCycleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertWeeklyStarCycleResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_UpdateWeeklyStarCycle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWeeklyStarServiceClient) SetWeeklyStarCycleStatus(ctx context.Context, in *SetWeeklyStarCycleStatusRequest, opts ...grpc.CallOption) (*SetWeeklyStarCycleStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetWeeklyStarCycleStatusResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_SetWeeklyStarCycleStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWeeklyStarServiceClient) ListWeeklyStarLeaderboard(ctx context.Context, in *ListWeeklyStarLeaderboardRequest, opts ...grpc.CallOption) (*ListWeeklyStarLeaderboardResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWeeklyStarLeaderboardResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_ListWeeklyStarLeaderboard_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWeeklyStarServiceClient) ListWeeklyStarSettlements(ctx context.Context, in *ListWeeklyStarSettlementsRequest, opts ...grpc.CallOption) (*ListWeeklyStarSettlementsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWeeklyStarSettlementsResponse)
	err := c.cc.Invoke(ctx, AdminWeeklyStarService_ListWeeklyStarSettlements_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminWeeklyStarServiceServer is the server API for AdminWeeklyStarService service.
// All implementations must embed UnimplementedAdminWeeklyStarServiceServer
// for forward compatibility.
//
// AdminWeeklyStarService 是后台活动管理访问周星周期、榜单和结算结果的唯一入口。
type AdminWeeklyStarServiceServer interface {
	ListWeeklyStarCycles(context.Context, *ListWeeklyStarCyclesRequest) (*ListWeeklyStarCyclesResponse, error)
	CreateWeeklyStarCycle(context.Context, *UpsertWeeklyStarCycleRequest) (*UpsertWeeklyStarCycleResponse, error)
	GetWeeklyStarCycle(context.Context, *GetWeeklyStarCycleRequest) (*GetWeeklyStarCycleResponse, error)
	UpdateWeeklyStarCycle(context.Context, *UpsertWeeklyStarCycleRequest) (*UpsertWeeklyStarCycleResponse, error)
	SetWeeklyStarCycleStatus(context.Context, *SetWeeklyStarCycleStatusRequest) (*SetWeeklyStarCycleStatusResponse, error)
	ListWeeklyStarLeaderboard(context.Context, *ListWeeklyStarLeaderboardRequest) (*ListWeeklyStarLeaderboardResponse, error)
	ListWeeklyStarSettlements(context.Context, *ListWeeklyStarSettlementsRequest) (*ListWeeklyStarSettlementsResponse, error)
	mustEmbedUnimplementedAdminWeeklyStarServiceServer()
}

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

func (UnimplementedAdminWeeklyStarServiceServer) ListWeeklyStarCycles(context.Context, *ListWeeklyStarCyclesRequest) (*ListWeeklyStarCyclesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWeeklyStarCycles not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) CreateWeeklyStarCycle(context.Context, *UpsertWeeklyStarCycleRequest) (*UpsertWeeklyStarCycleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateWeeklyStarCycle not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) GetWeeklyStarCycle(context.Context, *GetWeeklyStarCycleRequest) (*GetWeeklyStarCycleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWeeklyStarCycle not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) UpdateWeeklyStarCycle(context.Context, *UpsertWeeklyStarCycleRequest) (*UpsertWeeklyStarCycleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateWeeklyStarCycle not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) SetWeeklyStarCycleStatus(context.Context, *SetWeeklyStarCycleStatusRequest) (*SetWeeklyStarCycleStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetWeeklyStarCycleStatus not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) ListWeeklyStarLeaderboard(context.Context, *ListWeeklyStarLeaderboardRequest) (*ListWeeklyStarLeaderboardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWeeklyStarLeaderboard not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) ListWeeklyStarSettlements(context.Context, *ListWeeklyStarSettlementsRequest) (*ListWeeklyStarSettlementsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWeeklyStarSettlements not implemented")
}
func (UnimplementedAdminWeeklyStarServiceServer) mustEmbedUnimplementedAdminWeeklyStarServiceServer() {
}
func (UnimplementedAdminWeeklyStarServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminWeeklyStarServiceServer(s grpc.ServiceRegistrar, srv AdminWeeklyStarServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminWeeklyStarServiceServer 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(&AdminWeeklyStarService_ServiceDesc, srv)
}

func _AdminWeeklyStarService_ListWeeklyStarCycles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWeeklyStarCyclesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).ListWeeklyStarCycles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_ListWeeklyStarCycles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).ListWeeklyStarCycles(ctx, req.(*ListWeeklyStarCyclesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWeeklyStarService_CreateWeeklyStarCycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertWeeklyStarCycleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).CreateWeeklyStarCycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_CreateWeeklyStarCycle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).CreateWeeklyStarCycle(ctx, req.(*UpsertWeeklyStarCycleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWeeklyStarService_GetWeeklyStarCycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWeeklyStarCycleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).GetWeeklyStarCycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_GetWeeklyStarCycle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).GetWeeklyStarCycle(ctx, req.(*GetWeeklyStarCycleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWeeklyStarService_UpdateWeeklyStarCycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertWeeklyStarCycleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).UpdateWeeklyStarCycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_UpdateWeeklyStarCycle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).UpdateWeeklyStarCycle(ctx, req.(*UpsertWeeklyStarCycleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWeeklyStarService_SetWeeklyStarCycleStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetWeeklyStarCycleStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).SetWeeklyStarCycleStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_SetWeeklyStarCycleStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).SetWeeklyStarCycleStatus(ctx, req.(*SetWeeklyStarCycleStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWeeklyStarService_ListWeeklyStarLeaderboard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWeeklyStarLeaderboardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).ListWeeklyStarLeaderboard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_ListWeeklyStarLeaderboard_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).ListWeeklyStarLeaderboard(ctx, req.(*ListWeeklyStarLeaderboardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWeeklyStarService_ListWeeklyStarSettlements_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWeeklyStarSettlementsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWeeklyStarServiceServer).ListWeeklyStarSettlements(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWeeklyStarService_ListWeeklyStarSettlements_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWeeklyStarServiceServer).ListWeeklyStarSettlements(ctx, req.(*ListWeeklyStarSettlementsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminWeeklyStarService_ServiceDesc is the grpc.ServiceDesc for AdminWeeklyStarService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminWeeklyStarService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminWeeklyStarService",
	HandlerType: (*AdminWeeklyStarServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListWeeklyStarCycles",
			Handler:    _AdminWeeklyStarService_ListWeeklyStarCycles_Handler,
		},
		{
			MethodName: "CreateWeeklyStarCycle",
			Handler:    _AdminWeeklyStarService_CreateWeeklyStarCycle_Handler,
		},
		{
			MethodName: "GetWeeklyStarCycle",
			Handler:    _AdminWeeklyStarService_GetWeeklyStarCycle_Handler,
		},
		{
			MethodName: "UpdateWeeklyStarCycle",
			Handler:    _AdminWeeklyStarService_UpdateWeeklyStarCycle_Handler,
		},
		{
			MethodName: "SetWeeklyStarCycleStatus",
			Handler:    _AdminWeeklyStarService_SetWeeklyStarCycleStatus_Handler,
		},
		{
			MethodName: "ListWeeklyStarLeaderboard",
			Handler:    _AdminWeeklyStarService_ListWeeklyStarLeaderboard_Handler,
		},
		{
			MethodName: "ListWeeklyStarSettlements",
			Handler:    _AdminWeeklyStarService_ListWeeklyStarSettlements_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminCPWeeklyRankService_GetCPWeeklyRankConfig_FullMethodName       = "/hyapp.activity.v1.AdminCPWeeklyRankService/GetCPWeeklyRankConfig"
	AdminCPWeeklyRankService_UpdateCPWeeklyRankConfig_FullMethodName    = "/hyapp.activity.v1.AdminCPWeeklyRankService/UpdateCPWeeklyRankConfig"
	AdminCPWeeklyRankService_ListCPWeeklyRankSettlements_FullMethodName = "/hyapp.activity.v1.AdminCPWeeklyRankService/ListCPWeeklyRankSettlements"
)

// AdminCPWeeklyRankServiceClient is the client API for AdminCPWeeklyRankService 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.
//
// AdminCPWeeklyRankService 是后台配置 CP 周榜启停、奖励和查询发奖事实的入口。
type AdminCPWeeklyRankServiceClient interface {
	GetCPWeeklyRankConfig(ctx context.Context, in *GetCPWeeklyRankConfigRequest, opts ...grpc.CallOption) (*GetCPWeeklyRankConfigResponse, error)
	UpdateCPWeeklyRankConfig(ctx context.Context, in *UpdateCPWeeklyRankConfigRequest, opts ...grpc.CallOption) (*UpdateCPWeeklyRankConfigResponse, error)
	ListCPWeeklyRankSettlements(ctx context.Context, in *ListCPWeeklyRankSettlementsRequest, opts ...grpc.CallOption) (*ListCPWeeklyRankSettlementsResponse, error)
}

type adminCPWeeklyRankServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminCPWeeklyRankServiceClient(cc grpc.ClientConnInterface) AdminCPWeeklyRankServiceClient {
	return &adminCPWeeklyRankServiceClient{cc}
}

func (c *adminCPWeeklyRankServiceClient) GetCPWeeklyRankConfig(ctx context.Context, in *GetCPWeeklyRankConfigRequest, opts ...grpc.CallOption) (*GetCPWeeklyRankConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetCPWeeklyRankConfigResponse)
	err := c.cc.Invoke(ctx, AdminCPWeeklyRankService_GetCPWeeklyRankConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminCPWeeklyRankServiceClient) UpdateCPWeeklyRankConfig(ctx context.Context, in *UpdateCPWeeklyRankConfigRequest, opts ...grpc.CallOption) (*UpdateCPWeeklyRankConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpdateCPWeeklyRankConfigResponse)
	err := c.cc.Invoke(ctx, AdminCPWeeklyRankService_UpdateCPWeeklyRankConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminCPWeeklyRankServiceClient) ListCPWeeklyRankSettlements(ctx context.Context, in *ListCPWeeklyRankSettlementsRequest, opts ...grpc.CallOption) (*ListCPWeeklyRankSettlementsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListCPWeeklyRankSettlementsResponse)
	err := c.cc.Invoke(ctx, AdminCPWeeklyRankService_ListCPWeeklyRankSettlements_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminCPWeeklyRankServiceServer is the server API for AdminCPWeeklyRankService service.
// All implementations must embed UnimplementedAdminCPWeeklyRankServiceServer
// for forward compatibility.
//
// AdminCPWeeklyRankService 是后台配置 CP 周榜启停、奖励和查询发奖事实的入口。
type AdminCPWeeklyRankServiceServer interface {
	GetCPWeeklyRankConfig(context.Context, *GetCPWeeklyRankConfigRequest) (*GetCPWeeklyRankConfigResponse, error)
	UpdateCPWeeklyRankConfig(context.Context, *UpdateCPWeeklyRankConfigRequest) (*UpdateCPWeeklyRankConfigResponse, error)
	ListCPWeeklyRankSettlements(context.Context, *ListCPWeeklyRankSettlementsRequest) (*ListCPWeeklyRankSettlementsResponse, error)
	mustEmbedUnimplementedAdminCPWeeklyRankServiceServer()
}

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

func (UnimplementedAdminCPWeeklyRankServiceServer) GetCPWeeklyRankConfig(context.Context, *GetCPWeeklyRankConfigRequest) (*GetCPWeeklyRankConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCPWeeklyRankConfig not implemented")
}
func (UnimplementedAdminCPWeeklyRankServiceServer) UpdateCPWeeklyRankConfig(context.Context, *UpdateCPWeeklyRankConfigRequest) (*UpdateCPWeeklyRankConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCPWeeklyRankConfig not implemented")
}
func (UnimplementedAdminCPWeeklyRankServiceServer) ListCPWeeklyRankSettlements(context.Context, *ListCPWeeklyRankSettlementsRequest) (*ListCPWeeklyRankSettlementsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCPWeeklyRankSettlements not implemented")
}
func (UnimplementedAdminCPWeeklyRankServiceServer) mustEmbedUnimplementedAdminCPWeeklyRankServiceServer() {
}
func (UnimplementedAdminCPWeeklyRankServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminCPWeeklyRankServiceServer(s grpc.ServiceRegistrar, srv AdminCPWeeklyRankServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminCPWeeklyRankServiceServer 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(&AdminCPWeeklyRankService_ServiceDesc, srv)
}

func _AdminCPWeeklyRankService_GetCPWeeklyRankConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCPWeeklyRankConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminCPWeeklyRankServiceServer).GetCPWeeklyRankConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminCPWeeklyRankService_GetCPWeeklyRankConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminCPWeeklyRankServiceServer).GetCPWeeklyRankConfig(ctx, req.(*GetCPWeeklyRankConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminCPWeeklyRankService_UpdateCPWeeklyRankConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateCPWeeklyRankConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminCPWeeklyRankServiceServer).UpdateCPWeeklyRankConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminCPWeeklyRankService_UpdateCPWeeklyRankConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminCPWeeklyRankServiceServer).UpdateCPWeeklyRankConfig(ctx, req.(*UpdateCPWeeklyRankConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminCPWeeklyRankService_ListCPWeeklyRankSettlements_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCPWeeklyRankSettlementsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminCPWeeklyRankServiceServer).ListCPWeeklyRankSettlements(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminCPWeeklyRankService_ListCPWeeklyRankSettlements_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminCPWeeklyRankServiceServer).ListCPWeeklyRankSettlements(ctx, req.(*ListCPWeeklyRankSettlementsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminCPWeeklyRankService_ServiceDesc is the grpc.ServiceDesc for AdminCPWeeklyRankService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminCPWeeklyRankService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminCPWeeklyRankService",
	HandlerType: (*AdminCPWeeklyRankServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCPWeeklyRankConfig",
			Handler:    _AdminCPWeeklyRankService_GetCPWeeklyRankConfig_Handler,
		},
		{
			MethodName: "UpdateCPWeeklyRankConfig",
			Handler:    _AdminCPWeeklyRankService_UpdateCPWeeklyRankConfig_Handler,
		},
		{
			MethodName: "ListCPWeeklyRankSettlements",
			Handler:    _AdminCPWeeklyRankService_ListCPWeeklyRankSettlements_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminAgencyOpeningService_ListAgencyOpeningCycles_FullMethodName        = "/hyapp.activity.v1.AdminAgencyOpeningService/ListAgencyOpeningCycles"
	AdminAgencyOpeningService_CreateAgencyOpeningCycle_FullMethodName       = "/hyapp.activity.v1.AdminAgencyOpeningService/CreateAgencyOpeningCycle"
	AdminAgencyOpeningService_GetAgencyOpeningCycle_FullMethodName          = "/hyapp.activity.v1.AdminAgencyOpeningService/GetAgencyOpeningCycle"
	AdminAgencyOpeningService_UpdateAgencyOpeningCycle_FullMethodName       = "/hyapp.activity.v1.AdminAgencyOpeningService/UpdateAgencyOpeningCycle"
	AdminAgencyOpeningService_SetAgencyOpeningCycleStatus_FullMethodName    = "/hyapp.activity.v1.AdminAgencyOpeningService/SetAgencyOpeningCycleStatus"
	AdminAgencyOpeningService_ListAgencyOpeningApplications_FullMethodName  = "/hyapp.activity.v1.AdminAgencyOpeningService/ListAgencyOpeningApplications"
	AdminAgencyOpeningService_ReviewAgencyOpeningApplication_FullMethodName = "/hyapp.activity.v1.AdminAgencyOpeningService/ReviewAgencyOpeningApplication"
)

// AdminAgencyOpeningServiceClient is the client API for AdminAgencyOpeningService 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.
//
// AdminAgencyOpeningService 是后台配置开业周期、查看申请和榜单发奖结果的入口。
type AdminAgencyOpeningServiceClient interface {
	ListAgencyOpeningCycles(ctx context.Context, in *ListAgencyOpeningCyclesRequest, opts ...grpc.CallOption) (*ListAgencyOpeningCyclesResponse, error)
	CreateAgencyOpeningCycle(ctx context.Context, in *UpsertAgencyOpeningCycleRequest, opts ...grpc.CallOption) (*UpsertAgencyOpeningCycleResponse, error)
	GetAgencyOpeningCycle(ctx context.Context, in *GetAgencyOpeningCycleRequest, opts ...grpc.CallOption) (*GetAgencyOpeningCycleResponse, error)
	UpdateAgencyOpeningCycle(ctx context.Context, in *UpsertAgencyOpeningCycleRequest, opts ...grpc.CallOption) (*UpsertAgencyOpeningCycleResponse, error)
	SetAgencyOpeningCycleStatus(ctx context.Context, in *SetAgencyOpeningCycleStatusRequest, opts ...grpc.CallOption) (*SetAgencyOpeningCycleStatusResponse, error)
	ListAgencyOpeningApplications(ctx context.Context, in *ListAgencyOpeningApplicationsRequest, opts ...grpc.CallOption) (*ListAgencyOpeningApplicationsResponse, error)
	ReviewAgencyOpeningApplication(ctx context.Context, in *ReviewAgencyOpeningApplicationRequest, opts ...grpc.CallOption) (*ReviewAgencyOpeningApplicationResponse, error)
}

type adminAgencyOpeningServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminAgencyOpeningServiceClient(cc grpc.ClientConnInterface) AdminAgencyOpeningServiceClient {
	return &adminAgencyOpeningServiceClient{cc}
}

func (c *adminAgencyOpeningServiceClient) ListAgencyOpeningCycles(ctx context.Context, in *ListAgencyOpeningCyclesRequest, opts ...grpc.CallOption) (*ListAgencyOpeningCyclesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAgencyOpeningCyclesResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_ListAgencyOpeningCycles_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAgencyOpeningServiceClient) CreateAgencyOpeningCycle(ctx context.Context, in *UpsertAgencyOpeningCycleRequest, opts ...grpc.CallOption) (*UpsertAgencyOpeningCycleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertAgencyOpeningCycleResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_CreateAgencyOpeningCycle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAgencyOpeningServiceClient) GetAgencyOpeningCycle(ctx context.Context, in *GetAgencyOpeningCycleRequest, opts ...grpc.CallOption) (*GetAgencyOpeningCycleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetAgencyOpeningCycleResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_GetAgencyOpeningCycle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAgencyOpeningServiceClient) UpdateAgencyOpeningCycle(ctx context.Context, in *UpsertAgencyOpeningCycleRequest, opts ...grpc.CallOption) (*UpsertAgencyOpeningCycleResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertAgencyOpeningCycleResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_UpdateAgencyOpeningCycle_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAgencyOpeningServiceClient) SetAgencyOpeningCycleStatus(ctx context.Context, in *SetAgencyOpeningCycleStatusRequest, opts ...grpc.CallOption) (*SetAgencyOpeningCycleStatusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SetAgencyOpeningCycleStatusResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_SetAgencyOpeningCycleStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAgencyOpeningServiceClient) ListAgencyOpeningApplications(ctx context.Context, in *ListAgencyOpeningApplicationsRequest, opts ...grpc.CallOption) (*ListAgencyOpeningApplicationsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListAgencyOpeningApplicationsResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_ListAgencyOpeningApplications_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminAgencyOpeningServiceClient) ReviewAgencyOpeningApplication(ctx context.Context, in *ReviewAgencyOpeningApplicationRequest, opts ...grpc.CallOption) (*ReviewAgencyOpeningApplicationResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ReviewAgencyOpeningApplicationResponse)
	err := c.cc.Invoke(ctx, AdminAgencyOpeningService_ReviewAgencyOpeningApplication_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminAgencyOpeningServiceServer is the server API for AdminAgencyOpeningService service.
// All implementations must embed UnimplementedAdminAgencyOpeningServiceServer
// for forward compatibility.
//
// AdminAgencyOpeningService 是后台配置开业周期、查看申请和榜单发奖结果的入口。
type AdminAgencyOpeningServiceServer interface {
	ListAgencyOpeningCycles(context.Context, *ListAgencyOpeningCyclesRequest) (*ListAgencyOpeningCyclesResponse, error)
	CreateAgencyOpeningCycle(context.Context, *UpsertAgencyOpeningCycleRequest) (*UpsertAgencyOpeningCycleResponse, error)
	GetAgencyOpeningCycle(context.Context, *GetAgencyOpeningCycleRequest) (*GetAgencyOpeningCycleResponse, error)
	UpdateAgencyOpeningCycle(context.Context, *UpsertAgencyOpeningCycleRequest) (*UpsertAgencyOpeningCycleResponse, error)
	SetAgencyOpeningCycleStatus(context.Context, *SetAgencyOpeningCycleStatusRequest) (*SetAgencyOpeningCycleStatusResponse, error)
	ListAgencyOpeningApplications(context.Context, *ListAgencyOpeningApplicationsRequest) (*ListAgencyOpeningApplicationsResponse, error)
	ReviewAgencyOpeningApplication(context.Context, *ReviewAgencyOpeningApplicationRequest) (*ReviewAgencyOpeningApplicationResponse, error)
	mustEmbedUnimplementedAdminAgencyOpeningServiceServer()
}

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

func (UnimplementedAdminAgencyOpeningServiceServer) ListAgencyOpeningCycles(context.Context, *ListAgencyOpeningCyclesRequest) (*ListAgencyOpeningCyclesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAgencyOpeningCycles not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) CreateAgencyOpeningCycle(context.Context, *UpsertAgencyOpeningCycleRequest) (*UpsertAgencyOpeningCycleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAgencyOpeningCycle not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) GetAgencyOpeningCycle(context.Context, *GetAgencyOpeningCycleRequest) (*GetAgencyOpeningCycleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAgencyOpeningCycle not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) UpdateAgencyOpeningCycle(context.Context, *UpsertAgencyOpeningCycleRequest) (*UpsertAgencyOpeningCycleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAgencyOpeningCycle not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) SetAgencyOpeningCycleStatus(context.Context, *SetAgencyOpeningCycleStatusRequest) (*SetAgencyOpeningCycleStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAgencyOpeningCycleStatus not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) ListAgencyOpeningApplications(context.Context, *ListAgencyOpeningApplicationsRequest) (*ListAgencyOpeningApplicationsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAgencyOpeningApplications not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) ReviewAgencyOpeningApplication(context.Context, *ReviewAgencyOpeningApplicationRequest) (*ReviewAgencyOpeningApplicationResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReviewAgencyOpeningApplication not implemented")
}
func (UnimplementedAdminAgencyOpeningServiceServer) mustEmbedUnimplementedAdminAgencyOpeningServiceServer() {
}
func (UnimplementedAdminAgencyOpeningServiceServer) testEmbeddedByValue() {}

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

func RegisterAdminAgencyOpeningServiceServer(s grpc.ServiceRegistrar, srv AdminAgencyOpeningServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminAgencyOpeningServiceServer 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(&AdminAgencyOpeningService_ServiceDesc, srv)
}

func _AdminAgencyOpeningService_ListAgencyOpeningCycles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAgencyOpeningCyclesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).ListAgencyOpeningCycles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_ListAgencyOpeningCycles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).ListAgencyOpeningCycles(ctx, req.(*ListAgencyOpeningCyclesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAgencyOpeningService_CreateAgencyOpeningCycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertAgencyOpeningCycleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).CreateAgencyOpeningCycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_CreateAgencyOpeningCycle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).CreateAgencyOpeningCycle(ctx, req.(*UpsertAgencyOpeningCycleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAgencyOpeningService_GetAgencyOpeningCycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAgencyOpeningCycleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).GetAgencyOpeningCycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_GetAgencyOpeningCycle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).GetAgencyOpeningCycle(ctx, req.(*GetAgencyOpeningCycleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAgencyOpeningService_UpdateAgencyOpeningCycle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertAgencyOpeningCycleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).UpdateAgencyOpeningCycle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_UpdateAgencyOpeningCycle_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).UpdateAgencyOpeningCycle(ctx, req.(*UpsertAgencyOpeningCycleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAgencyOpeningService_SetAgencyOpeningCycleStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetAgencyOpeningCycleStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).SetAgencyOpeningCycleStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_SetAgencyOpeningCycleStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).SetAgencyOpeningCycleStatus(ctx, req.(*SetAgencyOpeningCycleStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAgencyOpeningService_ListAgencyOpeningApplications_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAgencyOpeningApplicationsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).ListAgencyOpeningApplications(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_ListAgencyOpeningApplications_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).ListAgencyOpeningApplications(ctx, req.(*ListAgencyOpeningApplicationsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminAgencyOpeningService_ReviewAgencyOpeningApplication_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReviewAgencyOpeningApplicationRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAgencyOpeningServiceServer).ReviewAgencyOpeningApplication(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAgencyOpeningService_ReviewAgencyOpeningApplication_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAgencyOpeningServiceServer).ReviewAgencyOpeningApplication(ctx, req.(*ReviewAgencyOpeningApplicationRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminAgencyOpeningService_ServiceDesc is the grpc.ServiceDesc for AdminAgencyOpeningService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminAgencyOpeningService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminAgencyOpeningService",
	HandlerType: (*AdminAgencyOpeningServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListAgencyOpeningCycles",
			Handler:    _AdminAgencyOpeningService_ListAgencyOpeningCycles_Handler,
		},
		{
			MethodName: "CreateAgencyOpeningCycle",
			Handler:    _AdminAgencyOpeningService_CreateAgencyOpeningCycle_Handler,
		},
		{
			MethodName: "GetAgencyOpeningCycle",
			Handler:    _AdminAgencyOpeningService_GetAgencyOpeningCycle_Handler,
		},
		{
			MethodName: "UpdateAgencyOpeningCycle",
			Handler:    _AdminAgencyOpeningService_UpdateAgencyOpeningCycle_Handler,
		},
		{
			MethodName: "SetAgencyOpeningCycleStatus",
			Handler:    _AdminAgencyOpeningService_SetAgencyOpeningCycleStatus_Handler,
		},
		{
			MethodName: "ListAgencyOpeningApplications",
			Handler:    _AdminAgencyOpeningService_ListAgencyOpeningApplications_Handler,
		},
		{
			MethodName: "ReviewAgencyOpeningApplication",
			Handler:    _AdminAgencyOpeningService_ReviewAgencyOpeningApplication_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.Errorf(codes.Unimplemented, "method GetSevenDayCheckInStatus not implemented")
}
func (UnimplementedSevenDayCheckInServiceServer) SignSevenDayCheckIn(context.Context, *SignSevenDayCheckInRequest) (*SignSevenDayCheckInResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method GetSevenDayCheckInConfig not implemented")
}
func (UnimplementedAdminSevenDayCheckInServiceServer) UpdateSevenDayCheckInConfig(context.Context, *UpdateSevenDayCheckInConfigRequest) (*UpdateSevenDayCheckInConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSevenDayCheckInConfig not implemented")
}
func (UnimplementedAdminSevenDayCheckInServiceServer) ListSevenDayCheckInClaims(context.Context, *ListSevenDayCheckInClaimsRequest) (*ListSevenDayCheckInClaimsResponse, error) {
	return nil, status.Errorf(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 pancis, 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.Errorf(codes.Unimplemented, "method ListLevelConfig not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) UpsertLevelTrack(context.Context, *UpsertLevelTrackRequest) (*UpsertLevelTrackResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertLevelTrack not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) UpsertLevelRule(context.Context, *UpsertLevelRuleRequest) (*UpsertLevelRuleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertLevelRule not implemented")
}
func (UnimplementedAdminGrowthLevelServiceServer) UpsertLevelTier(context.Context, *UpsertLevelTierRequest) (*UpsertLevelTierResponse, error) {
	return nil, status.Errorf(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 pancis, 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"
	AdminAchievementService_DeleteAchievementDefinition_FullMethodName = "/hyapp.activity.v1.AdminAchievementService/DeleteAchievementDefinition"
)

// 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)
	DeleteAchievementDefinition(ctx context.Context, in *DeleteAchievementDefinitionRequest, opts ...grpc.CallOption) (*DeleteAchievementDefinitionResponse, 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
}

func (c *adminAchievementServiceClient) DeleteAchievementDefinition(ctx context.Context, in *DeleteAchievementDefinitionRequest, opts ...grpc.CallOption) (*DeleteAchievementDefinitionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteAchievementDefinitionResponse)
	err := c.cc.Invoke(ctx, AdminAchievementService_DeleteAchievementDefinition_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)
	DeleteAchievementDefinition(context.Context, *DeleteAchievementDefinitionRequest) (*DeleteAchievementDefinitionResponse, 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.Errorf(codes.Unimplemented, "method ListAchievementDefinitions not implemented")
}
func (UnimplementedAdminAchievementServiceServer) UpsertAchievementDefinition(context.Context, *UpsertAchievementDefinitionRequest) (*UpsertAchievementDefinitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertAchievementDefinition not implemented")
}
func (UnimplementedAdminAchievementServiceServer) DeleteAchievementDefinition(context.Context, *DeleteAchievementDefinitionRequest) (*DeleteAchievementDefinitionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAchievementDefinition 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 pancis, 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)
}

func _AdminAchievementService_DeleteAchievementDefinition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAchievementDefinitionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminAchievementServiceServer).DeleteAchievementDefinition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminAchievementService_DeleteAchievementDefinition_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminAchievementServiceServer).DeleteAchievementDefinition(ctx, req.(*DeleteAchievementDefinitionRequest))
	}
	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,
		},
		{
			MethodName: "DeleteAchievementDefinition",
			Handler:    _AdminAchievementService_DeleteAchievementDefinition_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"
	AdminLuckyGiftService_GetLuckyGiftDrawSummary_FullMethodName = "/hyapp.activity.v1.AdminLuckyGiftService/GetLuckyGiftDrawSummary"
)

// 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)
	GetLuckyGiftDrawSummary(ctx context.Context, in *GetLuckyGiftDrawSummaryRequest, opts ...grpc.CallOption) (*GetLuckyGiftDrawSummaryResponse, 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
}

func (c *adminLuckyGiftServiceClient) GetLuckyGiftDrawSummary(ctx context.Context, in *GetLuckyGiftDrawSummaryRequest, opts ...grpc.CallOption) (*GetLuckyGiftDrawSummaryResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetLuckyGiftDrawSummaryResponse)
	err := c.cc.Invoke(ctx, AdminLuckyGiftService_GetLuckyGiftDrawSummary_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)
	GetLuckyGiftDrawSummary(context.Context, *GetLuckyGiftDrawSummaryRequest) (*GetLuckyGiftDrawSummaryResponse, 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.Errorf(codes.Unimplemented, "method GetLuckyGiftConfig not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) UpsertLuckyGiftConfig(context.Context, *UpsertLuckyGiftConfigRequest) (*UpsertLuckyGiftConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertLuckyGiftConfig not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) ListLuckyGiftConfigs(context.Context, *ListLuckyGiftConfigsRequest) (*ListLuckyGiftConfigsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListLuckyGiftConfigs not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) ListLuckyGiftDraws(context.Context, *ListLuckyGiftDrawsRequest) (*ListLuckyGiftDrawsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListLuckyGiftDraws not implemented")
}
func (UnimplementedAdminLuckyGiftServiceServer) GetLuckyGiftDrawSummary(context.Context, *GetLuckyGiftDrawSummaryRequest) (*GetLuckyGiftDrawSummaryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLuckyGiftDrawSummary 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 pancis, 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)
}

func _AdminLuckyGiftService_GetLuckyGiftDrawSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLuckyGiftDrawSummaryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminLuckyGiftServiceServer).GetLuckyGiftDrawSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminLuckyGiftService_GetLuckyGiftDrawSummary_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminLuckyGiftServiceServer).GetLuckyGiftDrawSummary(ctx, req.(*GetLuckyGiftDrawSummaryRequest))
	}
	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,
		},
		{
			MethodName: "GetLuckyGiftDrawSummary",
			Handler:    _AdminLuckyGiftService_GetLuckyGiftDrawSummary_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}

const (
	AdminWheelService_GetWheelConfig_FullMethodName      = "/hyapp.activity.v1.AdminWheelService/GetWheelConfig"
	AdminWheelService_UpsertWheelConfig_FullMethodName   = "/hyapp.activity.v1.AdminWheelService/UpsertWheelConfig"
	AdminWheelService_ListWheelDraws_FullMethodName      = "/hyapp.activity.v1.AdminWheelService/ListWheelDraws"
	AdminWheelService_GetWheelDrawSummary_FullMethodName = "/hyapp.activity.v1.AdminWheelService/GetWheelDrawSummary"
)

// AdminWheelServiceClient is the client API for AdminWheelService 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.
//
// AdminWheelService is the admin entry for wheel rule versions, draw records, and RTP statistics.
type AdminWheelServiceClient interface {
	GetWheelConfig(ctx context.Context, in *GetWheelConfigRequest, opts ...grpc.CallOption) (*GetWheelConfigResponse, error)
	UpsertWheelConfig(ctx context.Context, in *UpsertWheelConfigRequest, opts ...grpc.CallOption) (*UpsertWheelConfigResponse, error)
	ListWheelDraws(ctx context.Context, in *ListWheelDrawsRequest, opts ...grpc.CallOption) (*ListWheelDrawsResponse, error)
	GetWheelDrawSummary(ctx context.Context, in *GetWheelDrawSummaryRequest, opts ...grpc.CallOption) (*GetWheelDrawSummaryResponse, error)
}

type adminWheelServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewAdminWheelServiceClient(cc grpc.ClientConnInterface) AdminWheelServiceClient {
	return &adminWheelServiceClient{cc}
}

func (c *adminWheelServiceClient) GetWheelConfig(ctx context.Context, in *GetWheelConfigRequest, opts ...grpc.CallOption) (*GetWheelConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWheelConfigResponse)
	err := c.cc.Invoke(ctx, AdminWheelService_GetWheelConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWheelServiceClient) UpsertWheelConfig(ctx context.Context, in *UpsertWheelConfigRequest, opts ...grpc.CallOption) (*UpsertWheelConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UpsertWheelConfigResponse)
	err := c.cc.Invoke(ctx, AdminWheelService_UpsertWheelConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWheelServiceClient) ListWheelDraws(ctx context.Context, in *ListWheelDrawsRequest, opts ...grpc.CallOption) (*ListWheelDrawsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListWheelDrawsResponse)
	err := c.cc.Invoke(ctx, AdminWheelService_ListWheelDraws_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *adminWheelServiceClient) GetWheelDrawSummary(ctx context.Context, in *GetWheelDrawSummaryRequest, opts ...grpc.CallOption) (*GetWheelDrawSummaryResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetWheelDrawSummaryResponse)
	err := c.cc.Invoke(ctx, AdminWheelService_GetWheelDrawSummary_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AdminWheelServiceServer is the server API for AdminWheelService service.
// All implementations must embed UnimplementedAdminWheelServiceServer
// for forward compatibility.
//
// AdminWheelService is the admin entry for wheel rule versions, draw records, and RTP statistics.
type AdminWheelServiceServer interface {
	GetWheelConfig(context.Context, *GetWheelConfigRequest) (*GetWheelConfigResponse, error)
	UpsertWheelConfig(context.Context, *UpsertWheelConfigRequest) (*UpsertWheelConfigResponse, error)
	ListWheelDraws(context.Context, *ListWheelDrawsRequest) (*ListWheelDrawsResponse, error)
	GetWheelDrawSummary(context.Context, *GetWheelDrawSummaryRequest) (*GetWheelDrawSummaryResponse, error)
	mustEmbedUnimplementedAdminWheelServiceServer()
}

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

func (UnimplementedAdminWheelServiceServer) GetWheelConfig(context.Context, *GetWheelConfigRequest) (*GetWheelConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWheelConfig not implemented")
}
func (UnimplementedAdminWheelServiceServer) UpsertWheelConfig(context.Context, *UpsertWheelConfigRequest) (*UpsertWheelConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpsertWheelConfig not implemented")
}
func (UnimplementedAdminWheelServiceServer) ListWheelDraws(context.Context, *ListWheelDrawsRequest) (*ListWheelDrawsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWheelDraws not implemented")
}
func (UnimplementedAdminWheelServiceServer) GetWheelDrawSummary(context.Context, *GetWheelDrawSummaryRequest) (*GetWheelDrawSummaryResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWheelDrawSummary not implemented")
}
func (UnimplementedAdminWheelServiceServer) mustEmbedUnimplementedAdminWheelServiceServer() {}
func (UnimplementedAdminWheelServiceServer) testEmbeddedByValue()                           {}

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

func RegisterAdminWheelServiceServer(s grpc.ServiceRegistrar, srv AdminWheelServiceServer) {
	// If the following call pancis, it indicates UnimplementedAdminWheelServiceServer 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(&AdminWheelService_ServiceDesc, srv)
}

func _AdminWheelService_GetWheelConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWheelConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWheelServiceServer).GetWheelConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWheelService_GetWheelConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWheelServiceServer).GetWheelConfig(ctx, req.(*GetWheelConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWheelService_UpsertWheelConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertWheelConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWheelServiceServer).UpsertWheelConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWheelService_UpsertWheelConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWheelServiceServer).UpsertWheelConfig(ctx, req.(*UpsertWheelConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWheelService_ListWheelDraws_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWheelDrawsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWheelServiceServer).ListWheelDraws(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWheelService_ListWheelDraws_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWheelServiceServer).ListWheelDraws(ctx, req.(*ListWheelDrawsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AdminWheelService_GetWheelDrawSummary_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWheelDrawSummaryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AdminWheelServiceServer).GetWheelDrawSummary(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: AdminWheelService_GetWheelDrawSummary_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AdminWheelServiceServer).GetWheelDrawSummary(ctx, req.(*GetWheelDrawSummaryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// AdminWheelService_ServiceDesc is the grpc.ServiceDesc for AdminWheelService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var AdminWheelService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.activity.v1.AdminWheelService",
	HandlerType: (*AdminWheelServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetWheelConfig",
			Handler:    _AdminWheelService_GetWheelConfig_Handler,
		},
		{
			MethodName: "UpsertWheelConfig",
			Handler:    _AdminWheelService_UpsertWheelConfig_Handler,
		},
		{
			MethodName: "ListWheelDraws",
			Handler:    _AdminWheelService_ListWheelDraws_Handler,
		},
		{
			MethodName: "GetWheelDrawSummary",
			Handler:    _AdminWheelService_GetWheelDrawSummary_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/activity/v1/activity.proto",
}