// Code generated by protoc-gen-go-grpc. DO NOT EDIT.

package localserver

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

// GrpcManagerClient is the client API for GrpcManager 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 GrpcManagerClient interface {
	Link(ctx context.Context, opts ...grpc.CallOption) (GrpcManager_LinkClient, error)
	RegisterPeer(ctx context.Context, in *PeerRegisterRequest, opts ...grpc.CallOption) (*PeerRegisterResponse, error)
	ListPeers(ctx context.Context, in *PeerListRequest, opts ...grpc.CallOption) (*PeerListResponse, error)
	CreateSquad(ctx context.Context, in *SquadCreateRequest, opts ...grpc.CallOption) (*SquadCreateResponse, error)
	UpdateSquad(ctx context.Context, in *SquadUpdateRequest, opts ...grpc.CallOption) (*SquadUpdateResponse, error)
	DeleteSquad(ctx context.Context, in *SquadDeleteRequest, opts ...grpc.CallOption) (*SquadDeleteResponse, error)
	ListSquad(ctx context.Context, in *SquadListRequest, opts ...grpc.CallOption) (*SquadListResponse, error)
	ConnectSquad(ctx context.Context, in *SquadConnectRequest, opts ...grpc.CallOption) (*SquadConnectResponse, error)
	LeaveSquad(ctx context.Context, in *SquadLeaveRequest, opts ...grpc.CallOption) (*SquadLeaveResponse, error)
}

type grpcManagerClient struct {
	cc grpc.ClientConnInterface
}

func NewGrpcManagerClient(cc grpc.ClientConnInterface) GrpcManagerClient {
	return &grpcManagerClient{cc}
}

func (c *grpcManagerClient) Link(ctx context.Context, opts ...grpc.CallOption) (GrpcManager_LinkClient, error) {
	stream, err := c.cc.NewStream(ctx, &GrpcManager_ServiceDesc.Streams[0], "/manager.GrpcManager/Link", opts...)
	if err != nil {
		return nil, err
	}
	x := &grpcManagerLinkClient{stream}
	return x, nil
}

type GrpcManager_LinkClient interface {
	Send(*Request) error
	Recv() (*Response, error)
	grpc.ClientStream
}

type grpcManagerLinkClient struct {
	grpc.ClientStream
}

func (x *grpcManagerLinkClient) Send(m *Request) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *grpcManagerClient) RegisterPeer(ctx context.Context, in *PeerRegisterRequest, opts ...grpc.CallOption) (*PeerRegisterResponse, error) {
	out := new(PeerRegisterResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/RegisterPeer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) ListPeers(ctx context.Context, in *PeerListRequest, opts ...grpc.CallOption) (*PeerListResponse, error) {
	out := new(PeerListResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/ListPeers", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) CreateSquad(ctx context.Context, in *SquadCreateRequest, opts ...grpc.CallOption) (*SquadCreateResponse, error) {
	out := new(SquadCreateResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/CreateSquad", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) UpdateSquad(ctx context.Context, in *SquadUpdateRequest, opts ...grpc.CallOption) (*SquadUpdateResponse, error) {
	out := new(SquadUpdateResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/UpdateSquad", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) DeleteSquad(ctx context.Context, in *SquadDeleteRequest, opts ...grpc.CallOption) (*SquadDeleteResponse, error) {
	out := new(SquadDeleteResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/DeleteSquad", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) ListSquad(ctx context.Context, in *SquadListRequest, opts ...grpc.CallOption) (*SquadListResponse, error) {
	out := new(SquadListResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/ListSquad", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) ConnectSquad(ctx context.Context, in *SquadConnectRequest, opts ...grpc.CallOption) (*SquadConnectResponse, error) {
	out := new(SquadConnectResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/ConnectSquad", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *grpcManagerClient) LeaveSquad(ctx context.Context, in *SquadLeaveRequest, opts ...grpc.CallOption) (*SquadLeaveResponse, error) {
	out := new(SquadLeaveResponse)
	err := c.cc.Invoke(ctx, "/manager.GrpcManager/LeaveSquad", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GrpcManagerServer is the server API for GrpcManager service.
// All implementations must embed UnimplementedGrpcManagerServer
// for forward compatibility
type GrpcManagerServer interface {
	Link(GrpcManager_LinkServer) error
	RegisterPeer(context.Context, *PeerRegisterRequest) (*PeerRegisterResponse, error)
	ListPeers(context.Context, *PeerListRequest) (*PeerListResponse, error)
	CreateSquad(context.Context, *SquadCreateRequest) (*SquadCreateResponse, error)
	UpdateSquad(context.Context, *SquadUpdateRequest) (*SquadUpdateResponse, error)
	DeleteSquad(context.Context, *SquadDeleteRequest) (*SquadDeleteResponse, error)
	ListSquad(context.Context, *SquadListRequest) (*SquadListResponse, error)
	ConnectSquad(context.Context, *SquadConnectRequest) (*SquadConnectResponse, error)
	LeaveSquad(context.Context, *SquadLeaveRequest) (*SquadLeaveResponse, error)
	mustEmbedUnimplementedGrpcManagerServer()
}

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

func (UnimplementedGrpcManagerServer) Link(GrpcManager_LinkServer) error {
	return status.Errorf(codes.Unimplemented, "method Link not implemented")
}
func (UnimplementedGrpcManagerServer) RegisterPeer(context.Context, *PeerRegisterRequest) (*PeerRegisterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterPeer not implemented")
}
func (UnimplementedGrpcManagerServer) ListPeers(context.Context, *PeerListRequest) (*PeerListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPeers not implemented")
}
func (UnimplementedGrpcManagerServer) CreateSquad(context.Context, *SquadCreateRequest) (*SquadCreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSquad not implemented")
}
func (UnimplementedGrpcManagerServer) UpdateSquad(context.Context, *SquadUpdateRequest) (*SquadUpdateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSquad not implemented")
}
func (UnimplementedGrpcManagerServer) DeleteSquad(context.Context, *SquadDeleteRequest) (*SquadDeleteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSquad not implemented")
}
func (UnimplementedGrpcManagerServer) ListSquad(context.Context, *SquadListRequest) (*SquadListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSquad not implemented")
}
func (UnimplementedGrpcManagerServer) ConnectSquad(context.Context, *SquadConnectRequest) (*SquadConnectResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConnectSquad not implemented")
}
func (UnimplementedGrpcManagerServer) LeaveSquad(context.Context, *SquadLeaveRequest) (*SquadLeaveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LeaveSquad not implemented")
}
func (UnimplementedGrpcManagerServer) mustEmbedUnimplementedGrpcManagerServer() {}

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

func RegisterGrpcManagerServer(s grpc.ServiceRegistrar, srv GrpcManagerServer) {
	s.RegisterService(&GrpcManager_ServiceDesc, srv)
}

func _GrpcManager_Link_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(GrpcManagerServer).Link(&grpcManagerLinkServer{stream})
}

type GrpcManager_LinkServer interface {
	Send(*Response) error
	Recv() (*Request, error)
	grpc.ServerStream
}

type grpcManagerLinkServer struct {
	grpc.ServerStream
}

func (x *grpcManagerLinkServer) Send(m *Response) error {
	return x.ServerStream.SendMsg(m)
}

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

func _GrpcManager_RegisterPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PeerRegisterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).RegisterPeer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/RegisterPeer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).RegisterPeer(ctx, req.(*PeerRegisterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_ListPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PeerListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).ListPeers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/ListPeers",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).ListPeers(ctx, req.(*PeerListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_CreateSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).CreateSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/CreateSquad",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).CreateSquad(ctx, req.(*SquadCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_UpdateSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadUpdateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).UpdateSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/UpdateSquad",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).UpdateSquad(ctx, req.(*SquadUpdateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_DeleteSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadDeleteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).DeleteSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/DeleteSquad",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).DeleteSquad(ctx, req.(*SquadDeleteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_ListSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).ListSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/ListSquad",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).ListSquad(ctx, req.(*SquadListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_ConnectSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadConnectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).ConnectSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/ConnectSquad",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).ConnectSquad(ctx, req.(*SquadConnectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GrpcManager_LeaveSquad_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SquadLeaveRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GrpcManagerServer).LeaveSquad(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/manager.GrpcManager/LeaveSquad",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GrpcManagerServer).LeaveSquad(ctx, req.(*SquadLeaveRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GrpcManager_ServiceDesc is the grpc.ServiceDesc for GrpcManager service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GrpcManager_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "manager.GrpcManager",
	HandlerType: (*GrpcManagerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterPeer",
			Handler:    _GrpcManager_RegisterPeer_Handler,
		},
		{
			MethodName: "ListPeers",
			Handler:    _GrpcManager_ListPeers_Handler,
		},
		{
			MethodName: "CreateSquad",
			Handler:    _GrpcManager_CreateSquad_Handler,
		},
		{
			MethodName: "UpdateSquad",
			Handler:    _GrpcManager_UpdateSquad_Handler,
		},
		{
			MethodName: "DeleteSquad",
			Handler:    _GrpcManager_DeleteSquad_Handler,
		},
		{
			MethodName: "ListSquad",
			Handler:    _GrpcManager_ListSquad_Handler,
		},
		{
			MethodName: "ConnectSquad",
			Handler:    _GrpcManager_ConnectSquad_Handler,
		},
		{
			MethodName: "LeaveSquad",
			Handler:    _GrpcManager_LeaveSquad_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Link",
			Handler:       _GrpcManager_Link_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "grpc_manager.proto",
}