portbuster1337-ArachneC2/protobuf/rpb/rpc_grpc.pb.go

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

package rpb

import (
	context "context"
	apb "github.com/portbuster1337/ArachneC2/protobuf/apb"
	cpb "github.com/portbuster1337/ArachneC2/protobuf/cpb"
	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 (
	S_M0_FullMethodName  = "/rpb.S/M0"
	S_M1_FullMethodName  = "/rpb.S/M1"
	S_M2_FullMethodName  = "/rpb.S/M2"
	S_M3_FullMethodName  = "/rpb.S/M3"
	S_M4_FullMethodName  = "/rpb.S/M4"
	S_M5_FullMethodName  = "/rpb.S/M5"
	S_M6_FullMethodName  = "/rpb.S/M6"
	S_M7_FullMethodName  = "/rpb.S/M7"
	S_M8_FullMethodName  = "/rpb.S/M8"
	S_M9_FullMethodName  = "/rpb.S/M9"
	S_M10_FullMethodName = "/rpb.S/M10"
	S_M11_FullMethodName = "/rpb.S/M11"
	S_M12_FullMethodName = "/rpb.S/M12"
	S_M13_FullMethodName = "/rpb.S/M13"
)

// SClient is the client API for S 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 SClient interface {
	M0(ctx context.Context, in *cpb.Empty, opts ...grpc.CallOption) (*Version, error)
	M1(ctx context.Context, in *cpb.Empty, opts ...grpc.CallOption) (*Z27, error)
	M2(ctx context.Context, in *apb.Z4, opts ...grpc.CallOption) (*cpb.Empty, error)
	M3(ctx context.Context, in *apb.Z12, opts ...grpc.CallOption) (*apb.Z13, error)
	M4(ctx context.Context, in *apb.Z14, opts ...grpc.CallOption) (*apb.Z15, error)
	M5(ctx context.Context, in *apb.Z16, opts ...grpc.CallOption) (*apb.Z17, error)
	M6(ctx context.Context, in *apb.Z20, opts ...grpc.CallOption) (*apb.Z21, error)
	M7(ctx context.Context, in *apb.Z22, opts ...grpc.CallOption) (*apb.Z23, error)
	M8(ctx context.Context, in *apb.Z24, opts ...grpc.CallOption) (*apb.Z25, error)
	M9(ctx context.Context, in *apb.Z2, opts ...grpc.CallOption) (*apb.Z3, error)
	M10(ctx context.Context, in *apb.Z5, opts ...grpc.CallOption) (*apb.Z6, error)
	M11(ctx context.Context, opts ...grpc.CallOption) (S_M11Client, error)
	M12(ctx context.Context, in *apb.Z9, opts ...grpc.CallOption) (*apb.Z9, error)
	M13(ctx context.Context, opts ...grpc.CallOption) (S_M13Client, error)
}

type sClient struct {
	cc grpc.ClientConnInterface
}

func NewSClient(cc grpc.ClientConnInterface) SClient {
	return &sClient{cc}
}

func (c *sClient) M0(ctx context.Context, in *cpb.Empty, opts ...grpc.CallOption) (*Version, error) {
	out := new(Version)
	err := c.cc.Invoke(ctx, S_M0_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M1(ctx context.Context, in *cpb.Empty, opts ...grpc.CallOption) (*Z27, error) {
	out := new(Z27)
	err := c.cc.Invoke(ctx, S_M1_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M2(ctx context.Context, in *apb.Z4, opts ...grpc.CallOption) (*cpb.Empty, error) {
	out := new(cpb.Empty)
	err := c.cc.Invoke(ctx, S_M2_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M3(ctx context.Context, in *apb.Z12, opts ...grpc.CallOption) (*apb.Z13, error) {
	out := new(apb.Z13)
	err := c.cc.Invoke(ctx, S_M3_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M4(ctx context.Context, in *apb.Z14, opts ...grpc.CallOption) (*apb.Z15, error) {
	out := new(apb.Z15)
	err := c.cc.Invoke(ctx, S_M4_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M5(ctx context.Context, in *apb.Z16, opts ...grpc.CallOption) (*apb.Z17, error) {
	out := new(apb.Z17)
	err := c.cc.Invoke(ctx, S_M5_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M6(ctx context.Context, in *apb.Z20, opts ...grpc.CallOption) (*apb.Z21, error) {
	out := new(apb.Z21)
	err := c.cc.Invoke(ctx, S_M6_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M7(ctx context.Context, in *apb.Z22, opts ...grpc.CallOption) (*apb.Z23, error) {
	out := new(apb.Z23)
	err := c.cc.Invoke(ctx, S_M7_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M8(ctx context.Context, in *apb.Z24, opts ...grpc.CallOption) (*apb.Z25, error) {
	out := new(apb.Z25)
	err := c.cc.Invoke(ctx, S_M8_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M9(ctx context.Context, in *apb.Z2, opts ...grpc.CallOption) (*apb.Z3, error) {
	out := new(apb.Z3)
	err := c.cc.Invoke(ctx, S_M9_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M10(ctx context.Context, in *apb.Z5, opts ...grpc.CallOption) (*apb.Z6, error) {
	out := new(apb.Z6)
	err := c.cc.Invoke(ctx, S_M10_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M11(ctx context.Context, opts ...grpc.CallOption) (S_M11Client, error) {
	stream, err := c.cc.NewStream(ctx, &S_ServiceDesc.Streams[0], S_M11_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sM11Client{stream}
	return x, nil
}

type S_M11Client interface {
	Send(*apb.Z8) error
	Recv() (*apb.Z8, error)
	grpc.ClientStream
}

type sM11Client struct {
	grpc.ClientStream
}

func (x *sM11Client) Send(m *apb.Z8) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *sClient) M12(ctx context.Context, in *apb.Z9, opts ...grpc.CallOption) (*apb.Z9, error) {
	out := new(apb.Z9)
	err := c.cc.Invoke(ctx, S_M12_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sClient) M13(ctx context.Context, opts ...grpc.CallOption) (S_M13Client, error) {
	stream, err := c.cc.NewStream(ctx, &S_ServiceDesc.Streams[1], S_M13_FullMethodName, opts...)
	if err != nil {
		return nil, err
	}
	x := &sM13Client{stream}
	return x, nil
}

type S_M13Client interface {
	Send(*apb.Z10) error
	Recv() (*apb.Z10, error)
	grpc.ClientStream
}

type sM13Client struct {
	grpc.ClientStream
}

func (x *sM13Client) Send(m *apb.Z10) error {
	return x.ClientStream.SendMsg(m)
}

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

// SServer is the server API for S service.
// All implementations must embed UnimplementedSServer
// for forward compatibility
type SServer interface {
	M0(context.Context, *cpb.Empty) (*Version, error)
	M1(context.Context, *cpb.Empty) (*Z27, error)
	M2(context.Context, *apb.Z4) (*cpb.Empty, error)
	M3(context.Context, *apb.Z12) (*apb.Z13, error)
	M4(context.Context, *apb.Z14) (*apb.Z15, error)
	M5(context.Context, *apb.Z16) (*apb.Z17, error)
	M6(context.Context, *apb.Z20) (*apb.Z21, error)
	M7(context.Context, *apb.Z22) (*apb.Z23, error)
	M8(context.Context, *apb.Z24) (*apb.Z25, error)
	M9(context.Context, *apb.Z2) (*apb.Z3, error)
	M10(context.Context, *apb.Z5) (*apb.Z6, error)
	M11(S_M11Server) error
	M12(context.Context, *apb.Z9) (*apb.Z9, error)
	M13(S_M13Server) error
	mustEmbedUnimplementedSServer()
}

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

func (UnimplementedSServer) M0(context.Context, *cpb.Empty) (*Version, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M0 not implemented")
}
func (UnimplementedSServer) M1(context.Context, *cpb.Empty) (*Z27, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M1 not implemented")
}
func (UnimplementedSServer) M2(context.Context, *apb.Z4) (*cpb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M2 not implemented")
}
func (UnimplementedSServer) M3(context.Context, *apb.Z12) (*apb.Z13, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M3 not implemented")
}
func (UnimplementedSServer) M4(context.Context, *apb.Z14) (*apb.Z15, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M4 not implemented")
}
func (UnimplementedSServer) M5(context.Context, *apb.Z16) (*apb.Z17, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M5 not implemented")
}
func (UnimplementedSServer) M6(context.Context, *apb.Z20) (*apb.Z21, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M6 not implemented")
}
func (UnimplementedSServer) M7(context.Context, *apb.Z22) (*apb.Z23, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M7 not implemented")
}
func (UnimplementedSServer) M8(context.Context, *apb.Z24) (*apb.Z25, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M8 not implemented")
}
func (UnimplementedSServer) M9(context.Context, *apb.Z2) (*apb.Z3, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M9 not implemented")
}
func (UnimplementedSServer) M10(context.Context, *apb.Z5) (*apb.Z6, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M10 not implemented")
}
func (UnimplementedSServer) M11(S_M11Server) error {
	return status.Errorf(codes.Unimplemented, "method M11 not implemented")
}
func (UnimplementedSServer) M12(context.Context, *apb.Z9) (*apb.Z9, error) {
	return nil, status.Errorf(codes.Unimplemented, "method M12 not implemented")
}
func (UnimplementedSServer) M13(S_M13Server) error {
	return status.Errorf(codes.Unimplemented, "method M13 not implemented")
}
func (UnimplementedSServer) mustEmbedUnimplementedSServer() {}

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

func RegisterSServer(s grpc.ServiceRegistrar, srv SServer) {
	s.RegisterService(&S_ServiceDesc, srv)
}

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

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

func _S_M2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z4)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M2_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M2(ctx, req.(*apb.Z4))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M3_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z12)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M3(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M3_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M3(ctx, req.(*apb.Z12))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M4_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z14)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M4(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M4_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M4(ctx, req.(*apb.Z14))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M5_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z16)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M5(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M5_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M5(ctx, req.(*apb.Z16))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M6_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z20)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M6(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M6_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M6(ctx, req.(*apb.Z20))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M7_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z22)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M7(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M7_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M7(ctx, req.(*apb.Z22))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M8_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z24)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M8(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M8_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M8(ctx, req.(*apb.Z24))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M9_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z2)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M9(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M9_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M9(ctx, req.(*apb.Z2))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M10_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z5)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M10(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M10_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M10(ctx, req.(*apb.Z5))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M11_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SServer).M11(&sM11Server{stream})
}

type S_M11Server interface {
	Send(*apb.Z8) error
	Recv() (*apb.Z8, error)
	grpc.ServerStream
}

type sM11Server struct {
	grpc.ServerStream
}

func (x *sM11Server) Send(m *apb.Z8) error {
	return x.ServerStream.SendMsg(m)
}

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

func _S_M12_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(apb.Z9)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SServer).M12(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: S_M12_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SServer).M12(ctx, req.(*apb.Z9))
	}
	return interceptor(ctx, in, info, handler)
}

func _S_M13_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(SServer).M13(&sM13Server{stream})
}

type S_M13Server interface {
	Send(*apb.Z10) error
	Recv() (*apb.Z10, error)
	grpc.ServerStream
}

type sM13Server struct {
	grpc.ServerStream
}

func (x *sM13Server) Send(m *apb.Z10) error {
	return x.ServerStream.SendMsg(m)
}

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

// S_ServiceDesc is the grpc.ServiceDesc for S service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var S_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "rpb.S",
	HandlerType: (*SServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "M0",
			Handler:    _S_M0_Handler,
		},
		{
			MethodName: "M1",
			Handler:    _S_M1_Handler,
		},
		{
			MethodName: "M2",
			Handler:    _S_M2_Handler,
		},
		{
			MethodName: "M3",
			Handler:    _S_M3_Handler,
		},
		{
			MethodName: "M4",
			Handler:    _S_M4_Handler,
		},
		{
			MethodName: "M5",
			Handler:    _S_M5_Handler,
		},
		{
			MethodName: "M6",
			Handler:    _S_M6_Handler,
		},
		{
			MethodName: "M7",
			Handler:    _S_M7_Handler,
		},
		{
			MethodName: "M8",
			Handler:    _S_M8_Handler,
		},
		{
			MethodName: "M9",
			Handler:    _S_M9_Handler,
		},
		{
			MethodName: "M10",
			Handler:    _S_M10_Handler,
		},
		{
			MethodName: "M12",
			Handler:    _S_M12_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "M11",
			Handler:       _S_M11_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "M13",
			Handler:       _S_M13_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "rpb/rpc.proto",
}