Sillyv2/proto3/srpc/srpc_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.23.4
// source: srpc.proto

package srpc

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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	SillyGirlService_BucketGet_FullMethodName          = "/srpc.SillyGirlService/BucketGet"
	SillyGirlService_BucketSet_FullMethodName          = "/srpc.SillyGirlService/BucketSet"
	SillyGirlService_BucketDelete_FullMethodName       = "/srpc.SillyGirlService/BucketDelete"
	SillyGirlService_BucketKeys_FullMethodName         = "/srpc.SillyGirlService/BucketKeys"
	SillyGirlService_BucketLen_FullMethodName          = "/srpc.SillyGirlService/BucketLen"
	SillyGirlService_BucketGetAll_FullMethodName       = "/srpc.SillyGirlService/BucketGetAll"
	SillyGirlService_BucketBuckets_FullMethodName      = "/srpc.SillyGirlService/BucketBuckets"
	SillyGirlService_BucketWatch_FullMethodName        = "/srpc.SillyGirlService/BucketWatch"
	SillyGirlService_SenderGetUserId_FullMethodName    = "/srpc.SillyGirlService/SenderGetUserId"
	SillyGirlService_SenderGetUserName_FullMethodName  = "/srpc.SillyGirlService/SenderGetUserName"
	SillyGirlService_SenderGetChatId_FullMethodName    = "/srpc.SillyGirlService/SenderGetChatId"
	SillyGirlService_SenderGetChatName_FullMethodName  = "/srpc.SillyGirlService/SenderGetChatName"
	SillyGirlService_SenderGetMessageId_FullMethodName = "/srpc.SillyGirlService/SenderGetMessageId"
	SillyGirlService_SenderIsAdmin_FullMethodName      = "/srpc.SillyGirlService/SenderIsAdmin"
	SillyGirlService_SenderGetPlatform_FullMethodName  = "/srpc.SillyGirlService/SenderGetPlatform"
	SillyGirlService_SenderGetBotId_FullMethodName     = "/srpc.SillyGirlService/SenderGetBotId"
	SillyGirlService_SenderGetContent_FullMethodName   = "/srpc.SillyGirlService/SenderGetContent"
	SillyGirlService_SenderSetContent_FullMethodName   = "/srpc.SillyGirlService/SenderSetContent"
	SillyGirlService_SenderContinue_FullMethodName     = "/srpc.SillyGirlService/SenderContinue"
	SillyGirlService_SenderListen_FullMethodName       = "/srpc.SillyGirlService/SenderListen"
	SillyGirlService_SenderEvent_FullMethodName        = "/srpc.SillyGirlService/SenderEvent"
	SillyGirlService_SenderReply_FullMethodName        = "/srpc.SillyGirlService/SenderReply"
	SillyGirlService_SenderParam_FullMethodName        = "/srpc.SillyGirlService/SenderParam"
	SillyGirlService_SenderAction_FullMethodName       = "/srpc.SillyGirlService/SenderAction"
	SillyGirlService_SenderDestroy_FullMethodName      = "/srpc.SillyGirlService/SenderDestroy"
	SillyGirlService_AdapterRegist_FullMethodName      = "/srpc.SillyGirlService/AdapterRegist"
	SillyGirlService_AdapterReceive_FullMethodName     = "/srpc.SillyGirlService/AdapterReceive"
	SillyGirlService_AdapterPush_FullMethodName        = "/srpc.SillyGirlService/AdapterPush"
	SillyGirlService_AdapterDestroy_FullMethodName     = "/srpc.SillyGirlService/AdapterDestroy"
	SillyGirlService_AdapterSender_FullMethodName      = "/srpc.SillyGirlService/AdapterSender"
	SillyGirlService_Console_FullMethodName            = "/srpc.SillyGirlService/Console"
)

// SillyGirlServiceClient is the client API for SillyGirlService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type SillyGirlServiceClient interface {
	BucketGet(ctx context.Context, in *BucketKeyRequest, opts ...grpc.CallOption) (*Default, error)
	BucketSet(ctx context.Context, in *BucketSetRequest, opts ...grpc.CallOption) (*BucketSetResponse, error)
	BucketDelete(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*Empty, error)
	BucketKeys(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*BucketKeysResponse, error)
	BucketLen(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*LenResponse, error)
	BucketGetAll(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*Default, error)
	BucketBuckets(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*BucketsResponse, error)
	BucketWatch(ctx context.Context, opts ...grpc.CallOption) (SillyGirlService_BucketWatchClient, error)
	SenderGetUserId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderGetUserName(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderGetChatId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderGetChatName(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderGetMessageId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderIsAdmin(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*BoolResponse, error)
	SenderGetPlatform(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderGetBotId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderGetContent(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderSetContent(ctx context.Context, in *SenderContentRequest, opts ...grpc.CallOption) (*Empty, error)
	SenderContinue(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Empty, error)
	SenderListen(ctx context.Context, opts ...grpc.CallOption) (SillyGirlService_SenderListenClient, error)
	SenderEvent(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error)
	SenderReply(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Default, error)
	SenderParam(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Default, error)
	SenderAction(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Default, error)
	SenderDestroy(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Empty, error)
	AdapterRegist(ctx context.Context, opts ...grpc.CallOption) (SillyGirlService_AdapterRegistClient, error)
	AdapterReceive(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Empty, error)
	AdapterPush(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Default, error)
	AdapterDestroy(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Empty, error)
	AdapterSender(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Default, error)
	Console(ctx context.Context, in *ConsoleRequest, opts ...grpc.CallOption) (*Empty, error)
}

type sillyGirlServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSillyGirlServiceClient(cc grpc.ClientConnInterface) SillyGirlServiceClient {
	return &sillyGirlServiceClient{cc}
}

func (c *sillyGirlServiceClient) BucketGet(ctx context.Context, in *BucketKeyRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketGet_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketSet(ctx context.Context, in *BucketSetRequest, opts ...grpc.CallOption) (*BucketSetResponse, error) {
	out := new(BucketSetResponse)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketSet_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketDelete(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketDelete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketKeys(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*BucketKeysResponse, error) {
	out := new(BucketKeysResponse)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketKeys_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketLen(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*LenResponse, error) {
	out := new(LenResponse)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketLen_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketGetAll(ctx context.Context, in *BucketRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketGetAll_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketBuckets(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*BucketsResponse, error) {
	out := new(BucketsResponse)
	err := c.cc.Invoke(ctx, SillyGirlService_BucketBuckets_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) BucketWatch(ctx context.Context, opts ...grpc.CallOption) (SillyGirlService_BucketWatchClient, error) {
	stream, err := c.cc.NewStream(ctx, &SillyGirlService_ServiceDesc.Streams[0], SillyGirlService_BucketWatch_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sillyGirlServiceBucketWatchClient{stream}
	return x, nil
}

type SillyGirlService_BucketWatchClient interface {
	Send(*BucketWatchRequest) error
	Recv() (*BucketWatchResponse, error)
	grpc.ClientStream
}

type sillyGirlServiceBucketWatchClient struct {
	grpc.ClientStream
}

func (x *sillyGirlServiceBucketWatchClient) Send(m *BucketWatchRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *sillyGirlServiceBucketWatchClient) Recv() (*BucketWatchResponse, error) {
	m := new(BucketWatchResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *sillyGirlServiceClient) SenderGetUserId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetUserId_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetUserName(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetUserName_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetChatId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetChatId_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetChatName(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetChatName_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetMessageId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetMessageId_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderIsAdmin(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*BoolResponse, error) {
	out := new(BoolResponse)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderIsAdmin_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetPlatform(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetPlatform_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetBotId(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetBotId_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderGetContent(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderGetContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderSetContent(ctx context.Context, in *SenderContentRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderSetContent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderContinue(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderContinue_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderListen(ctx context.Context, opts ...grpc.CallOption) (SillyGirlService_SenderListenClient, error) {
	stream, err := c.cc.NewStream(ctx, &SillyGirlService_ServiceDesc.Streams[1], SillyGirlService_SenderListen_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sillyGirlServiceSenderListenClient{stream}
	return x, nil
}

type SillyGirlService_SenderListenClient interface {
	Send(*SenderListenRequest) error
	Recv() (*SenderListenResponse, error)
	grpc.ClientStream
}

type sillyGirlServiceSenderListenClient struct {
	grpc.ClientStream
}

func (x *sillyGirlServiceSenderListenClient) Send(m *SenderListenRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *sillyGirlServiceSenderListenClient) Recv() (*SenderListenResponse, error) {
	m := new(SenderListenResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *sillyGirlServiceClient) SenderEvent(ctx context.Context, in *SenderRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderEvent_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderReply(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderReply_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderParam(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderParam_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderAction(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderAction_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) SenderDestroy(ctx context.Context, in *ReplyRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_SenderDestroy_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) AdapterRegist(ctx context.Context, opts ...grpc.CallOption) (SillyGirlService_AdapterRegistClient, error) {
	stream, err := c.cc.NewStream(ctx, &SillyGirlService_ServiceDesc.Streams[2], SillyGirlService_AdapterRegist_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sillyGirlServiceAdapterRegistClient{stream}
	return x, nil
}

type SillyGirlService_AdapterRegistClient interface {
	Send(*AdapterRegistRequest) error
	Recv() (*Default, error)
	grpc.ClientStream
}

type sillyGirlServiceAdapterRegistClient struct {
	grpc.ClientStream
}

func (x *sillyGirlServiceAdapterRegistClient) Send(m *AdapterRegistRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *sillyGirlServiceAdapterRegistClient) Recv() (*Default, error) {
	m := new(Default)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *sillyGirlServiceClient) AdapterReceive(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_AdapterReceive_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) AdapterPush(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_AdapterPush_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) AdapterDestroy(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_AdapterDestroy_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) AdapterSender(ctx context.Context, in *AdapterRequest, opts ...grpc.CallOption) (*Default, error) {
	out := new(Default)
	err := c.cc.Invoke(ctx, SillyGirlService_AdapterSender_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sillyGirlServiceClient) Console(ctx context.Context, in *ConsoleRequest, opts ...grpc.CallOption) (*Empty, error) {
	out := new(Empty)
	err := c.cc.Invoke(ctx, SillyGirlService_Console_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SillyGirlServiceServer is the server API for SillyGirlService service.
// All implementations must embed UnimplementedSillyGirlServiceServer
// for forward compatibility
type SillyGirlServiceServer interface {
	BucketGet(context.Context, *BucketKeyRequest) (*Default, error)
	BucketSet(context.Context, *BucketSetRequest) (*BucketSetResponse, error)
	BucketDelete(context.Context, *BucketRequest) (*Empty, error)
	BucketKeys(context.Context, *BucketRequest) (*BucketKeysResponse, error)
	BucketLen(context.Context, *BucketRequest) (*LenResponse, error)
	BucketGetAll(context.Context, *BucketRequest) (*Default, error)
	BucketBuckets(context.Context, *Empty) (*BucketsResponse, error)
	BucketWatch(SillyGirlService_BucketWatchServer) error
	SenderGetUserId(context.Context, *SenderRequest) (*Default, error)
	SenderGetUserName(context.Context, *SenderRequest) (*Default, error)
	SenderGetChatId(context.Context, *SenderRequest) (*Default, error)
	SenderGetChatName(context.Context, *SenderRequest) (*Default, error)
	SenderGetMessageId(context.Context, *SenderRequest) (*Default, error)
	SenderIsAdmin(context.Context, *SenderRequest) (*BoolResponse, error)
	SenderGetPlatform(context.Context, *SenderRequest) (*Default, error)
	SenderGetBotId(context.Context, *SenderRequest) (*Default, error)
	SenderGetContent(context.Context, *SenderRequest) (*Default, error)
	SenderSetContent(context.Context, *SenderContentRequest) (*Empty, error)
	SenderContinue(context.Context, *SenderRequest) (*Empty, error)
	SenderListen(SillyGirlService_SenderListenServer) error
	SenderEvent(context.Context, *SenderRequest) (*Default, error)
	SenderReply(context.Context, *ReplyRequest) (*Default, error)
	SenderParam(context.Context, *ReplyRequest) (*Default, error)
	SenderAction(context.Context, *ReplyRequest) (*Default, error)
	SenderDestroy(context.Context, *ReplyRequest) (*Empty, error)
	AdapterRegist(SillyGirlService_AdapterRegistServer) error
	AdapterReceive(context.Context, *AdapterRequest) (*Empty, error)
	AdapterPush(context.Context, *AdapterRequest) (*Default, error)
	AdapterDestroy(context.Context, *AdapterRequest) (*Empty, error)
	AdapterSender(context.Context, *AdapterRequest) (*Default, error)
	Console(context.Context, *ConsoleRequest) (*Empty, error)
	mustEmbedUnimplementedSillyGirlServiceServer()
}

// UnimplementedSillyGirlServiceServer must be embedded to have forward compatible implementations.
type UnimplementedSillyGirlServiceServer struct {
}

func (UnimplementedSillyGirlServiceServer) BucketGet(context.Context, *BucketKeyRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketGet not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketSet(context.Context, *BucketSetRequest) (*BucketSetResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketSet not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketDelete(context.Context, *BucketRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketDelete not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketKeys(context.Context, *BucketRequest) (*BucketKeysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketKeys not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketLen(context.Context, *BucketRequest) (*LenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketLen not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketGetAll(context.Context, *BucketRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketGetAll not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketBuckets(context.Context, *Empty) (*BucketsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BucketBuckets not implemented")
}
func (UnimplementedSillyGirlServiceServer) BucketWatch(SillyGirlService_BucketWatchServer) error {
	return status.Errorf(codes.Unimplemented, "method BucketWatch not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetUserId(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetUserId not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetUserName(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetUserName not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetChatId(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetChatId not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetChatName(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetChatName not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetMessageId(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetMessageId not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderIsAdmin(context.Context, *SenderRequest) (*BoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderIsAdmin not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetPlatform(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetPlatform not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetBotId(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetBotId not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderGetContent(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderGetContent not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderSetContent(context.Context, *SenderContentRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderSetContent not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderContinue(context.Context, *SenderRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderContinue not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderListen(SillyGirlService_SenderListenServer) error {
	return status.Errorf(codes.Unimplemented, "method SenderListen not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderEvent(context.Context, *SenderRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderEvent not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderReply(context.Context, *ReplyRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderReply not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderParam(context.Context, *ReplyRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderParam not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderAction(context.Context, *ReplyRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderAction not implemented")
}
func (UnimplementedSillyGirlServiceServer) SenderDestroy(context.Context, *ReplyRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SenderDestroy not implemented")
}
func (UnimplementedSillyGirlServiceServer) AdapterRegist(SillyGirlService_AdapterRegistServer) error {
	return status.Errorf(codes.Unimplemented, "method AdapterRegist not implemented")
}
func (UnimplementedSillyGirlServiceServer) AdapterReceive(context.Context, *AdapterRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdapterReceive not implemented")
}
func (UnimplementedSillyGirlServiceServer) AdapterPush(context.Context, *AdapterRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdapterPush not implemented")
}
func (UnimplementedSillyGirlServiceServer) AdapterDestroy(context.Context, *AdapterRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdapterDestroy not implemented")
}
func (UnimplementedSillyGirlServiceServer) AdapterSender(context.Context, *AdapterRequest) (*Default, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AdapterSender not implemented")
}
func (UnimplementedSillyGirlServiceServer) Console(context.Context, *ConsoleRequest) (*Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Console not implemented")
}
func (UnimplementedSillyGirlServiceServer) mustEmbedUnimplementedSillyGirlServiceServer() {}

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

func RegisterSillyGirlServiceServer(s grpc.ServiceRegistrar, srv SillyGirlServiceServer) {
	s.RegisterService(&SillyGirlService_ServiceDesc, srv)
}

func _SillyGirlService_BucketGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BucketKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketGet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketGet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketGet(ctx, req.(*BucketKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BucketSetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketSet(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketSet_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketSet(ctx, req.(*BucketSetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BucketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketDelete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketDelete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketDelete(ctx, req.(*BucketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketKeys_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BucketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketKeys(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketKeys_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketKeys(ctx, req.(*BucketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BucketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketLen(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketLen_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketLen(ctx, req.(*BucketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketGetAll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BucketRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketGetAll(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketGetAll_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketGetAll(ctx, req.(*BucketRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketBuckets_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).BucketBuckets(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_BucketBuckets_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).BucketBuckets(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_BucketWatch_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SillyGirlServiceServer).BucketWatch(&sillyGirlServiceBucketWatchServer{stream})
}

type SillyGirlService_BucketWatchServer interface {
	Send(*BucketWatchResponse) error
	Recv() (*BucketWatchRequest, error)
	grpc.ServerStream
}

type sillyGirlServiceBucketWatchServer struct {
	grpc.ServerStream
}

func (x *sillyGirlServiceBucketWatchServer) Send(m *BucketWatchResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *sillyGirlServiceBucketWatchServer) Recv() (*BucketWatchRequest, error) {
	m := new(BucketWatchRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _SillyGirlService_SenderGetUserId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetUserId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetUserId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetUserId(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetUserName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetUserName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetUserName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetUserName(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetChatId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetChatId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetChatId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetChatId(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetChatName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetChatName(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetChatName_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetChatName(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetMessageId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetMessageId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetMessageId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetMessageId(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderIsAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderIsAdmin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderIsAdmin_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderIsAdmin(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetPlatform_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetPlatform(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetPlatform_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetPlatform(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetBotId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetBotId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetBotId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetBotId(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderGetContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderGetContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderGetContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderGetContent(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderSetContent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderContentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderSetContent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderSetContent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderSetContent(ctx, req.(*SenderContentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderContinue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderContinue(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderContinue_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderContinue(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderListen_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SillyGirlServiceServer).SenderListen(&sillyGirlServiceSenderListenServer{stream})
}

type SillyGirlService_SenderListenServer interface {
	Send(*SenderListenResponse) error
	Recv() (*SenderListenRequest, error)
	grpc.ServerStream
}

type sillyGirlServiceSenderListenServer struct {
	grpc.ServerStream
}

func (x *sillyGirlServiceSenderListenServer) Send(m *SenderListenResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *sillyGirlServiceSenderListenServer) Recv() (*SenderListenRequest, error) {
	m := new(SenderListenRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _SillyGirlService_SenderEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SenderRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderEvent(ctx, req.(*SenderRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderReply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderReply(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderReply_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderReply(ctx, req.(*ReplyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderParam_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderParam(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderParam_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderParam(ctx, req.(*ReplyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderAction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderAction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderAction_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderAction(ctx, req.(*ReplyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_SenderDestroy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReplyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).SenderDestroy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_SenderDestroy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).SenderDestroy(ctx, req.(*ReplyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_AdapterRegist_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SillyGirlServiceServer).AdapterRegist(&sillyGirlServiceAdapterRegistServer{stream})
}

type SillyGirlService_AdapterRegistServer interface {
	Send(*Default) error
	Recv() (*AdapterRegistRequest, error)
	grpc.ServerStream
}

type sillyGirlServiceAdapterRegistServer struct {
	grpc.ServerStream
}

func (x *sillyGirlServiceAdapterRegistServer) Send(m *Default) error {
	return x.ServerStream.SendMsg(m)
}

func (x *sillyGirlServiceAdapterRegistServer) Recv() (*AdapterRegistRequest, error) {
	m := new(AdapterRegistRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _SillyGirlService_AdapterReceive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdapterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).AdapterReceive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_AdapterReceive_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).AdapterReceive(ctx, req.(*AdapterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_AdapterPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdapterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).AdapterPush(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_AdapterPush_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).AdapterPush(ctx, req.(*AdapterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_AdapterDestroy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdapterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).AdapterDestroy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_AdapterDestroy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).AdapterDestroy(ctx, req.(*AdapterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_AdapterSender_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdapterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).AdapterSender(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_AdapterSender_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).AdapterSender(ctx, req.(*AdapterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SillyGirlService_Console_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsoleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SillyGirlServiceServer).Console(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SillyGirlService_Console_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SillyGirlServiceServer).Console(ctx, req.(*ConsoleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SillyGirlService_ServiceDesc is the grpc.ServiceDesc for SillyGirlService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SillyGirlService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "srpc.SillyGirlService",
	HandlerType: (*SillyGirlServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "BucketGet",
			Handler:    _SillyGirlService_BucketGet_Handler,
		},
		{
			MethodName: "BucketSet",
			Handler:    _SillyGirlService_BucketSet_Handler,
		},
		{
			MethodName: "BucketDelete",
			Handler:    _SillyGirlService_BucketDelete_Handler,
		},
		{
			MethodName: "BucketKeys",
			Handler:    _SillyGirlService_BucketKeys_Handler,
		},
		{
			MethodName: "BucketLen",
			Handler:    _SillyGirlService_BucketLen_Handler,
		},
		{
			MethodName: "BucketGetAll",
			Handler:    _SillyGirlService_BucketGetAll_Handler,
		},
		{
			MethodName: "BucketBuckets",
			Handler:    _SillyGirlService_BucketBuckets_Handler,
		},
		{
			MethodName: "SenderGetUserId",
			Handler:    _SillyGirlService_SenderGetUserId_Handler,
		},
		{
			MethodName: "SenderGetUserName",
			Handler:    _SillyGirlService_SenderGetUserName_Handler,
		},
		{
			MethodName: "SenderGetChatId",
			Handler:    _SillyGirlService_SenderGetChatId_Handler,
		},
		{
			MethodName: "SenderGetChatName",
			Handler:    _SillyGirlService_SenderGetChatName_Handler,
		},
		{
			MethodName: "SenderGetMessageId",
			Handler:    _SillyGirlService_SenderGetMessageId_Handler,
		},
		{
			MethodName: "SenderIsAdmin",
			Handler:    _SillyGirlService_SenderIsAdmin_Handler,
		},
		{
			MethodName: "SenderGetPlatform",
			Handler:    _SillyGirlService_SenderGetPlatform_Handler,
		},
		{
			MethodName: "SenderGetBotId",
			Handler:    _SillyGirlService_SenderGetBotId_Handler,
		},
		{
			MethodName: "SenderGetContent",
			Handler:    _SillyGirlService_SenderGetContent_Handler,
		},
		{
			MethodName: "SenderSetContent",
			Handler:    _SillyGirlService_SenderSetContent_Handler,
		},
		{
			MethodName: "SenderContinue",
			Handler:    _SillyGirlService_SenderContinue_Handler,
		},
		{
			MethodName: "SenderEvent",
			Handler:    _SillyGirlService_SenderEvent_Handler,
		},
		{
			MethodName: "SenderReply",
			Handler:    _SillyGirlService_SenderReply_Handler,
		},
		{
			MethodName: "SenderParam",
			Handler:    _SillyGirlService_SenderParam_Handler,
		},
		{
			MethodName: "SenderAction",
			Handler:    _SillyGirlService_SenderAction_Handler,
		},
		{
			MethodName: "SenderDestroy",
			Handler:    _SillyGirlService_SenderDestroy_Handler,
		},
		{
			MethodName: "AdapterReceive",
			Handler:    _SillyGirlService_AdapterReceive_Handler,
		},
		{
			MethodName: "AdapterPush",
			Handler:    _SillyGirlService_AdapterPush_Handler,
		},
		{
			MethodName: "AdapterDestroy",
			Handler:    _SillyGirlService_AdapterDestroy_Handler,
		},
		{
			MethodName: "AdapterSender",
			Handler:    _SillyGirlService_AdapterSender_Handler,
		},
		{
			MethodName: "Console",
			Handler:    _SillyGirlService_Console_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "BucketWatch",
			Handler:       _SillyGirlService_BucketWatch_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "SenderListen",
			Handler:       _SillyGirlService_SenderListen_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "AdapterRegist",
			Handler:       _SillyGirlService_AdapterRegist_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "srpc.proto",
}